917 lines
28 KiB
Rust
917 lines
28 KiB
Rust
//@ run-pass
|
|
//@ edition:2021
|
|
//@ compile-flags: --test
|
|
|
|
#![allow(incomplete_features)]
|
|
#![feature(async_closure)]
|
|
#![feature(auto_traits)]
|
|
#![feature(box_patterns)]
|
|
#![feature(const_trait_impl)]
|
|
#![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)]
|
|
#![feature(type_ascription)]
|
|
#![feature(yeet_expr)]
|
|
#![deny(unused_macros)]
|
|
|
|
// These macros force the use of AST pretty-printing by converting the input to
|
|
// a particular fragment specifier.
|
|
macro_rules! block { ($block:block) => { stringify!($block) }; }
|
|
macro_rules! expr { ($expr:expr) => { stringify!($expr) }; }
|
|
macro_rules! item { ($item:item) => { stringify!($item) }; }
|
|
macro_rules! meta { ($meta:meta) => { stringify!($meta) }; }
|
|
macro_rules! pat { ($pat:pat) => { stringify!($pat) }; }
|
|
macro_rules! path { ($path:path) => { stringify!($path) }; }
|
|
macro_rules! stmt { ($stmt:stmt) => { stringify!($stmt) }; }
|
|
macro_rules! ty { ($ty:ty) => { stringify!($ty) }; }
|
|
macro_rules! vis { ($vis:vis) => { stringify!($vis) }; }
|
|
|
|
// Use this when AST pretty-printing and TokenStream pretty-printing give
|
|
// the same result (which is preferable.)
|
|
macro_rules! c1 {
|
|
($frag:ident, [$($tt:tt)*], $s:literal) => {
|
|
assert_eq!($frag!($($tt)*), $s);
|
|
assert_eq!(stringify!($($tt)*), $s);
|
|
};
|
|
}
|
|
|
|
// Use this when AST pretty-printing and TokenStream pretty-printing give
|
|
// different results.
|
|
//
|
|
// `c1` and `c2` could be in a single macro, but having them separate makes it
|
|
// 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 $(,)?) => {
|
|
assert_ne!($s1, $s2, "should use `c1!` instead");
|
|
assert_eq!($frag!($($tt)*), $s1);
|
|
assert_eq!(stringify!($($tt)*), $s2);
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_block() {
|
|
c1!(block, [ {} ], "{}");
|
|
c1!(block, [ { true } ], "{ true }");
|
|
c1!(block, [ { return } ], "{ return }");
|
|
c1!(block, [ { return; } ], "{ return; }");
|
|
c1!(block,
|
|
[ {
|
|
let _;
|
|
true
|
|
} ],
|
|
"{ let _; true }"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_expr() {
|
|
// ExprKind::Array
|
|
c1!(expr, [ [] ], "[]");
|
|
c1!(expr, [ [true] ], "[true]");
|
|
c2!(expr, [ [true,] ], "[true]", "[true,]");
|
|
c1!(expr, [ [true, true] ], "[true, true]");
|
|
|
|
// ExprKind::ConstBlock
|
|
// FIXME: todo
|
|
|
|
// ExprKind::Call
|
|
c1!(expr, [ f() ], "f()");
|
|
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,)");
|
|
c1!(expr, [ ()() ], "()()");
|
|
|
|
// ExprKind::MethodCall
|
|
c1!(expr, [ x.f() ], "x.f()");
|
|
c1!(expr, [ x.f::<u8>() ], "x.f::<u8>()");
|
|
c1!(expr, [ x.collect::<Vec<_>>() ], "x.collect::<Vec<_>>()");
|
|
|
|
// ExprKind::Tup
|
|
c1!(expr, [ () ], "()");
|
|
c1!(expr, [ (true,) ], "(true,)");
|
|
c1!(expr, [ (true, false) ], "(true, false)");
|
|
c2!(expr, [ (true, false,) ], "(true, false)", "(true, false,)");
|
|
|
|
// ExprKind::Binary
|
|
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");
|
|
c1!(expr, [ a & b & !c ], "a & b & !c");
|
|
c1!(expr, [ a + b * c - d + -1 * -2 - -3], "a + b * c - d + -1 * -2 - -3");
|
|
c1!(expr, [ x = !y ], "x = !y");
|
|
|
|
// ExprKind::Unary
|
|
c1!(expr, [ *expr ], "*expr");
|
|
c1!(expr, [ !expr ], "!expr");
|
|
c1!(expr, [ -expr ], "-expr");
|
|
|
|
// ExprKind::Lit
|
|
c1!(expr, [ 'x' ], "'x'");
|
|
c1!(expr, [ 1_000_i8 ], "1_000_i8");
|
|
c1!(expr, [ 1.00000000000000001 ], "1.00000000000000001");
|
|
|
|
// ExprKind::Cast
|
|
c1!(expr, [ expr as T ], "expr as T");
|
|
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 {}",
|
|
);
|
|
c1!(expr,
|
|
[ match () { _ if let _ = Struct {} => {} } ],
|
|
"match () { _ if let _ = Struct {} => {} }"
|
|
);
|
|
|
|
// ExprKind::If
|
|
c1!(expr, [ if true {} ], "if true {}");
|
|
c1!(expr, [ if !true {} ], "if !true {}");
|
|
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 {
|
|
} else if false {
|
|
} ],
|
|
"if true {} else if false {}"
|
|
);
|
|
c1!(expr,
|
|
[ if true {
|
|
} else if false {
|
|
} else {
|
|
} ],
|
|
"if true {} else if false {} else {}"
|
|
);
|
|
c1!(expr,
|
|
[ 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 {}");
|
|
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 {}");
|
|
c1!(expr, [ 'a: for _ in x {} ], "'a: for _ in x {}");
|
|
|
|
// ExprKind::Loop
|
|
c1!(expr, [ loop {} ], "loop {}");
|
|
c1!(expr, [ 'a: loop {} ], "'a: loop {}");
|
|
|
|
// ExprKind::Match
|
|
c1!(expr, [ match self {} ], "match self {}");
|
|
c1!(expr,
|
|
[ match self {
|
|
Ok => 1,
|
|
} ],
|
|
"match self { Ok => 1, }"
|
|
);
|
|
c1!(expr,
|
|
[ match self {
|
|
Ok => 1,
|
|
Err => 0,
|
|
} ],
|
|
"match self { Ok => 1, Err => 0, }"
|
|
);
|
|
macro_rules! c2_match_arm {
|
|
([ $expr:expr ], $expr_expected:expr, $tokens_expected:expr $(,)?) => {
|
|
c2!(expr, [ match () { _ => $expr } ], $expr_expected, $tokens_expected);
|
|
};
|
|
}
|
|
c2_match_arm!(
|
|
[ { 1 } - 1 ],
|
|
"match () { _ => ({ 1 }) - 1, }",
|
|
"match () { _ => { 1 } - 1 }",
|
|
);
|
|
c2_match_arm!(
|
|
[ m!() - 1 ],
|
|
"match () { _ => m!() - 1, }",
|
|
"match () { _ => m!() - 1 }",
|
|
);
|
|
c2_match_arm!(
|
|
[ m![] - 1 ],
|
|
"match () { _ => m![] - 1, }",
|
|
"match () { _ => m![] - 1 }",
|
|
);
|
|
c2_match_arm!(
|
|
[ m! {} - 1 ],
|
|
"match () { _ => m! {} - 1, }",
|
|
"match () { _ => m! {} - 1 }",
|
|
);
|
|
|
|
// ExprKind::Closure
|
|
c1!(expr, [ || {} ], "|| {}");
|
|
c1!(expr, [ |x| {} ], "|x| {}");
|
|
c1!(expr, [ |x: u8| {} ], "|x: u8| {}");
|
|
c1!(expr, [ || () ], "|| ()");
|
|
c1!(expr, [ move || self ], "move || self");
|
|
c1!(expr, [ async || self ], "async || self");
|
|
c1!(expr, [ async move || self ], "async move || self");
|
|
c1!(expr, [ static || self ], "static || self");
|
|
c1!(expr, [ static move || self ], "static move || self");
|
|
c1!(expr, [ static async || self ], "static async || self");
|
|
c1!(expr, [ static async move || self ], "static async move || self");
|
|
c1!(expr, [ || -> u8 { self } ], "|| -> u8 { self }");
|
|
c2!(expr, [ 1 + || {} ], "1 + (|| {})", "1 + || {}"); // AST??
|
|
|
|
// ExprKind::Block
|
|
c1!(expr, [ {} ], "{}");
|
|
c1!(expr, [ unsafe {} ], "unsafe {}");
|
|
c1!(expr, [ 'a: {} ], "'a: {}");
|
|
c1!(expr, [ #[attr] {} ], "#[attr] {}");
|
|
c2!(expr,
|
|
[
|
|
{
|
|
#![attr]
|
|
}
|
|
],
|
|
"{\n\
|
|
\x20 #![attr]\n\
|
|
}",
|
|
"{ #![attr] }"
|
|
);
|
|
|
|
// ExprKind::Async
|
|
c1!(expr, [ async {} ], "async {}");
|
|
c1!(expr, [ async move {} ], "async move {}");
|
|
|
|
// ExprKind::Await
|
|
c1!(expr, [ expr.await ], "expr.await");
|
|
|
|
// ExprKind::TryBlock
|
|
c1!(expr, [ try {} ], "try {}");
|
|
|
|
// ExprKind::Assign
|
|
c1!(expr, [ expr = true ], "expr = true");
|
|
|
|
// ExprKind::AssignOp
|
|
c1!(expr, [ expr += true ], "expr += true");
|
|
|
|
// ExprKind::Field
|
|
c1!(expr, [ expr.field ], "expr.field");
|
|
c1!(expr, [ expr.0 ], "expr.0");
|
|
|
|
// ExprKind::Index
|
|
c1!(expr, [ expr[true] ], "expr[true]");
|
|
|
|
// ExprKind::Range
|
|
c1!(expr, [ .. ], "..");
|
|
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");
|
|
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
|
|
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");
|
|
c1!(expr, [ break 'a ], "break 'a");
|
|
c1!(expr, [ break true ], "break true");
|
|
c1!(expr, [ break 'a true ], "break 'a true");
|
|
|
|
// ExprKind::Continue
|
|
c1!(expr, [ continue ], "continue");
|
|
c1!(expr, [ continue 'a ], "continue 'a");
|
|
|
|
// ExprKind::Ret
|
|
c1!(expr, [ return ], "return");
|
|
c1!(expr, [ return true ], "return true");
|
|
|
|
// ExprKind::InlineAsm: untestable because this test works pre-expansion.
|
|
|
|
// ExprKind::OffsetOf: untestable because this test works pre-expansion.
|
|
|
|
// ExprKind::MacCall
|
|
c1!(expr, [ mac!(...) ], "mac!(...)");
|
|
c1!(expr, [ mac![...] ], "mac![...]");
|
|
c1!(expr, [ mac! { ... } ], "mac! { ... }");
|
|
|
|
// ExprKind::Struct
|
|
c1!(expr, [ Struct {} ], "Struct {}");
|
|
c1!(expr, [ <Struct as Trait>::Type {} ], "<Struct as Trait>::Type {}");
|
|
c1!(expr, [ Struct { .. } ], "Struct { .. }");
|
|
c1!(expr, [ Struct { ..base } ], "Struct { ..base }");
|
|
c1!(expr, [ Struct { x } ], "Struct { x }");
|
|
c1!(expr, [ Struct { x, .. } ], "Struct { x, .. }");
|
|
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
|
|
c1!(expr, [ [(); 0] ], "[(); 0]");
|
|
|
|
// ExprKind::Paren
|
|
c1!(expr, [ (expr) ], "(expr)");
|
|
|
|
// ExprKind::Try
|
|
c1!(expr, [ expr? ], "expr?");
|
|
|
|
// ExprKind::Yield
|
|
c1!(expr, [ yield ], "yield");
|
|
c1!(expr, [ yield true ], "yield true");
|
|
|
|
// ExprKind::Yeet
|
|
c1!(expr, [ do yeet ], "do yeet");
|
|
c1!(expr, [ do yeet 0 ], "do yeet 0");
|
|
|
|
// ExprKind::Become
|
|
// FIXME: todo
|
|
|
|
// ExprKind::IncludedBytes
|
|
// FIXME: todo
|
|
|
|
// ExprKind::FormatArgs: untestable because this test works pre-expansion.
|
|
|
|
// ExprKind::Err: untestable.
|
|
}
|
|
|
|
#[test]
|
|
fn test_item() {
|
|
// ItemKind::ExternCrate
|
|
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 };" // FIXME
|
|
);
|
|
c1!(item, [ pub use A::*; ], "pub use A::*;");
|
|
|
|
// ItemKind::Static
|
|
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
|
|
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() {}"
|
|
);
|
|
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>>) {}"
|
|
);
|
|
|
|
// ItemKind::Mod
|
|
c1!(item, [ pub mod m; ], "pub mod m;");
|
|
c1!(item, [ mod m {} ], "mod m {}");
|
|
c1!(item, [ unsafe mod m; ], "unsafe mod m;");
|
|
c1!(item, [ unsafe mod m {} ], "unsafe mod m {}");
|
|
|
|
// ItemKind::ForeignMod
|
|
c1!(item, [ extern "C" {} ], "extern \"C\" {}");
|
|
c2!(item,
|
|
[ pub extern "C" {} ],
|
|
"extern \"C\" {}", // ??
|
|
"pub extern \"C\" {}"
|
|
);
|
|
c1!(item, [ unsafe extern "C++" {} ], "unsafe extern \"C++\" {}");
|
|
|
|
// ItemKind::GlobalAsm: untestable because this test works pre-expansion.
|
|
|
|
// ItemKind::TyAlias
|
|
c2!(item,
|
|
[
|
|
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
|
|
c1!(item, [ pub enum Void {} ], "pub enum Void {}");
|
|
c1!(item,
|
|
[
|
|
enum Empty {
|
|
Unit,
|
|
Tuple(),
|
|
Struct {},
|
|
}
|
|
],
|
|
"enum Empty { Unit, Tuple(), Struct {}, }"
|
|
);
|
|
c2!(item,
|
|
[
|
|
enum Enum<T>
|
|
where
|
|
T: 'a,
|
|
{
|
|
Unit,
|
|
Tuple(T),
|
|
Struct { t: T },
|
|
}
|
|
],
|
|
"enum Enum<T> where T: 'a {\n\
|
|
\x20 Unit,\n\
|
|
\x20 Tuple(T),\n\
|
|
\x20 Struct {\n\
|
|
\x20 t: T,\n\
|
|
\x20 },\n\
|
|
}",
|
|
"enum Enum<T> where T: 'a, { Unit, Tuple(T), Struct { t: T }, }"
|
|
);
|
|
|
|
// ItemKind::Struct
|
|
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,
|
|
[
|
|
struct Struct<T>
|
|
where
|
|
T: 'a,
|
|
{
|
|
t: T,
|
|
}
|
|
],
|
|
"struct Struct<T> where T: 'a {\n\
|
|
\x20 t: T,\n\
|
|
}",
|
|
"struct Struct<T> where T: 'a, { t: T, }"
|
|
);
|
|
|
|
// ItemKind::Union
|
|
c1!(item, [ pub union Union {} ], "pub union Union {}");
|
|
c2!(item,
|
|
[
|
|
union Union<T> where T: 'a {
|
|
t: T,
|
|
}
|
|
],
|
|
"union Union<T> where T: 'a {\n\
|
|
\x20 t: T,\n\
|
|
}",
|
|
"union Union<T> where T: 'a { t: T, }"
|
|
);
|
|
|
|
// ItemKind::Trait
|
|
c1!(item, [ pub unsafe auto trait Send {} ], "pub unsafe auto trait Send {}");
|
|
c2!(item,
|
|
[
|
|
trait Trait<'a>: Sized
|
|
where
|
|
Self: 'a,
|
|
{
|
|
}
|
|
],
|
|
"trait Trait<'a>: Sized where Self: 'a {}",
|
|
"trait Trait<'a>: Sized where Self: 'a, {}"
|
|
);
|
|
|
|
// ItemKind::TraitAlias
|
|
c1!(item,
|
|
[ 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 {}");
|
|
c1!(item, [ impl<T> Struct<T> {} ], "impl<T> Struct<T> {}");
|
|
c1!(item, [ pub impl Trait for Struct {} ], "pub impl Trait for 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
|
|
c1!(item, [ mac!(...); ], "mac!(...);");
|
|
c1!(item, [ mac![...]; ], "mac![...];");
|
|
c1!(item, [ mac! { ... } ], "mac! { ... }");
|
|
|
|
// ItemKind::MacroDef
|
|
c1!(item,
|
|
[
|
|
macro_rules! stringify {
|
|
() => {};
|
|
}
|
|
],
|
|
"macro_rules! stringify { () => {}; }"
|
|
);
|
|
c2!(item,
|
|
[ pub macro stringify() {} ],
|
|
"pub macro stringify { () => {} }", // ??
|
|
"pub macro stringify() {}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_meta() {
|
|
c1!(meta, [ k ], "k");
|
|
c1!(meta, [ k = "v" ], "k = \"v\"");
|
|
c1!(meta, [ list(k1, k2 = "v") ], "list(k1, k2 = \"v\")");
|
|
c1!(meta, [ serde::k ], "serde::k");
|
|
}
|
|
|
|
#[test]
|
|
fn test_pat() {
|
|
// PatKind::Wild
|
|
c1!(pat, [ _ ], "_");
|
|
|
|
// PatKind::Ident
|
|
c1!(pat, [ _x ], "_x");
|
|
c1!(pat, [ ref _x ], "ref _x");
|
|
c1!(pat, [ mut _x ], "mut _x");
|
|
c1!(pat, [ ref mut _x ], "ref mut _x");
|
|
c1!(pat, [ ref mut _x @ _ ], "ref mut _x @ _");
|
|
|
|
// PatKind::Struct
|
|
c1!(pat, [ Struct {} ], "Struct {}");
|
|
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 }");
|
|
c1!(pat, [ Struct { x: _x } ], "Struct { x: _x }");
|
|
c1!(pat, [ Struct { .. } ], "Struct { .. }");
|
|
c1!(pat, [ Struct { x, .. } ], "Struct { x, .. }");
|
|
c1!(pat, [ Struct { x: _x, .. } ], "Struct { x: _x, .. }");
|
|
c1!(pat, [ <Struct as Trait>::Type {} ], "<Struct as Trait>::Type {}");
|
|
|
|
// PatKind::TupleStruct
|
|
c1!(pat, [ Tuple() ], "Tuple()");
|
|
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, ..)");
|
|
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");
|
|
|
|
// PatKind::Path
|
|
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, [ () ], "()");
|
|
c1!(pat, [ (true,) ], "(true,)");
|
|
c1!(pat, [ (true, false) ], "(true, false)");
|
|
|
|
// PatKind::Box
|
|
c1!(pat, [ box pat ], "box pat");
|
|
|
|
// PatKind::Ref
|
|
c1!(pat, [ &pat ], "&pat");
|
|
c1!(pat, [ &mut pat ], "&mut pat");
|
|
|
|
// PatKind::Lit
|
|
c1!(pat, [ 1_000_i8 ], "1_000_i8");
|
|
|
|
// PatKind::Range
|
|
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, [ [] ], "[]");
|
|
c1!(pat, [ [true] ], "[true]");
|
|
c2!(pat, [ [true,] ], "[true]", "[true,]");
|
|
c1!(pat, [ [true, false] ], "[true, false]");
|
|
|
|
// PatKind::Rest
|
|
c1!(pat, [ .. ], "..");
|
|
|
|
// PatKind::Never
|
|
c1!(pat, [ Some(!) ], "Some(!)");
|
|
c1!(pat, [ None | Some(!) ], "None | Some(!)");
|
|
|
|
// PatKind::Paren
|
|
c1!(pat, [ (pat) ], "(pat)");
|
|
|
|
// PatKind::MacCall
|
|
c1!(pat, [ mac!(...) ], "mac!(...)");
|
|
c1!(pat, [ mac![...] ], "mac![...]");
|
|
c1!(pat, [ mac! { ... } ], "mac! { ... }");
|
|
}
|
|
|
|
#[test]
|
|
fn test_path() {
|
|
c1!(path, [ thing ], "thing");
|
|
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() -> ()");
|
|
}
|
|
|
|
#[test]
|
|
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 (a, b) = (1, 2) ], "let (a, b) = (1, 2);", "let (a, b) = (1, 2)");
|
|
c2!(stmt,
|
|
[ let (a, b): (u32, u32) = (1, 2) ],
|
|
"let (a, b): (u32, u32) = (1, 2);",
|
|
"let (a, b): (u32, u32) = (1, 2)"
|
|
);
|
|
c2!(stmt,
|
|
[ let _ = f() else { return; } ],
|
|
"let _ = f() else { return; };",
|
|
"let _ = f() else { return; }",
|
|
);
|
|
macro_rules! c2_let_expr_minus_one {
|
|
([ $expr:expr ], $stmt_expected:expr, $tokens_expected:expr $(,)?) => {
|
|
c2!(stmt, [ let _ = $expr - 1 ], $stmt_expected, $tokens_expected);
|
|
};
|
|
}
|
|
c2_let_expr_minus_one!(
|
|
[ match void {} ],
|
|
"let _ = match void {} - 1;",
|
|
"let _ = match void {} - 1",
|
|
);
|
|
macro_rules! c2_let_expr_else_return {
|
|
([ $expr:expr ], $stmt_expected:expr, $tokens_expected:expr $(,)?) => {
|
|
c2!(stmt, [ let _ = $expr else { return; } ], $stmt_expected, $tokens_expected);
|
|
};
|
|
}
|
|
c2_let_expr_else_return!(
|
|
[ f() ],
|
|
"let _ = f() else { return; };",
|
|
"let _ = f() else { return; }",
|
|
);
|
|
|
|
// StmtKind::Item
|
|
c1!(stmt, [ struct S; ], "struct S;");
|
|
c1!(stmt, [ struct S {} ], "struct S {}");
|
|
|
|
// StmtKind::Expr
|
|
c1!(stmt, [ loop {} ], "loop {}");
|
|
|
|
// StmtKind::Semi
|
|
c2!(stmt, [ 1 + 1 ], "1 + 1;", "1 + 1");
|
|
macro_rules! c2_expr_as_stmt {
|
|
// Parse as expr, then reparse as stmt.
|
|
//
|
|
// The c2_minus_one macro below can't directly call `c2!(stmt, ...)`
|
|
// because `$expr - 1` cannot be parsed directly as a stmt. A statement
|
|
// boundary occurs after the `match void {}`, after which the `-` token
|
|
// hits "no rules expected this token in macro call".
|
|
//
|
|
// The unwanted statement boundary is exactly why the pretty-printer is
|
|
// injecting parentheses around the subexpression, which is the behavior
|
|
// we are interested in testing.
|
|
([ $expr:expr ], $stmt_expected:expr, $tokens_expected:expr $(,)?) => {
|
|
c2!(stmt, [ $expr ], $stmt_expected, $tokens_expected);
|
|
};
|
|
}
|
|
macro_rules! c2_minus_one {
|
|
([ $expr:expr ], $stmt_expected:expr, $tokens_expected:expr $(,)?) => {
|
|
c2_expr_as_stmt!([ $expr - 1 ], $stmt_expected, $tokens_expected);
|
|
};
|
|
}
|
|
c2_minus_one!(
|
|
[ match void {} ],
|
|
"(match void {}) - 1;",
|
|
"match void {} - 1",
|
|
);
|
|
c2_minus_one!(
|
|
[ match void {}() ],
|
|
"(match void {})() - 1;",
|
|
"match void {}() - 1",
|
|
);
|
|
c2_minus_one!(
|
|
[ match void {}[0] ],
|
|
"(match void {})[0] - 1;",
|
|
"match void {}[0] - 1",
|
|
);
|
|
c2_minus_one!(
|
|
[ loop { break 1; } ],
|
|
"(loop { break 1; }) - 1;",
|
|
"loop { break 1; } - 1",
|
|
);
|
|
c2_minus_one!(
|
|
[ m!() ],
|
|
"m!() - 1;",
|
|
"m!() - 1"
|
|
);
|
|
c2_minus_one!(
|
|
[ m![] ],
|
|
"m![] - 1;",
|
|
"m![] - 1"
|
|
);
|
|
c2_minus_one!(
|
|
[ m! {} ],
|
|
"(m! {}) - 1;",
|
|
"m! {} - 1"
|
|
);
|
|
|
|
// StmtKind::Empty
|
|
c1!(stmt, [ ; ], ";");
|
|
|
|
// StmtKind::MacCall
|
|
c1!(stmt, [ mac!(...) ], "mac!(...)");
|
|
c1!(stmt, [ mac![...] ], "mac![...]");
|
|
c1!(stmt, [ mac! { ... } ], "mac! { ... }");
|
|
}
|
|
|
|
#[test]
|
|
fn test_ty() {
|
|
// TyKind::Slice
|
|
c1!(ty, [ [T] ], "[T]");
|
|
|
|
// TyKind::Array
|
|
c1!(ty, [ [T; 0] ], "[T; 0]");
|
|
|
|
// TyKind::Ptr
|
|
c1!(ty, [ *const T ], "*const T");
|
|
c1!(ty, [ *mut T ], "*mut T");
|
|
|
|
// TyKind::Ref
|
|
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)");
|
|
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, [ ! ], "!");
|
|
|
|
// TyKind::Tup
|
|
c1!(ty, [ () ], "()");
|
|
c1!(ty, [ (T,) ], "(T,)");
|
|
c1!(ty, [ (T, U) ], "(T, U)");
|
|
|
|
// TyKind::AnonStruct: untestable in isolation.
|
|
|
|
// TyKind::AnonUnion: untestable in isolation.
|
|
|
|
// TyKind::Path
|
|
c1!(ty, [ T ], "T");
|
|
c1!(ty, [ Ref<'a> ], "Ref<'a>");
|
|
c1!(ty, [ PhantomData<T> ], "PhantomData<T>");
|
|
c2!(ty, [ PhantomData::<T> ], "PhantomData<T>", "PhantomData::<T>");
|
|
c1!(ty, [ Fn() -> ! ], "Fn() -> !");
|
|
c1!(ty, [ Fn(u8) -> ! ], "Fn(u8) -> !");
|
|
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");
|
|
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");
|
|
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)");
|
|
|
|
// TyKind::Typeof: unused for now.
|
|
|
|
// TyKind::Infer
|
|
c1!(ty, [ _ ], "_");
|
|
|
|
// TyKind::ImplicitSelf: there is no syntax for this.
|
|
|
|
// TyKind::MacCall
|
|
c1!(ty, [ mac!(...) ], "mac!(...)");
|
|
c1!(ty, [ mac![...] ], "mac![...]");
|
|
c1!(ty, [ mac! { ... } ], "mac! { ... }");
|
|
|
|
// TyKind::Err: untestable.
|
|
|
|
// TyKind::CVarArgs
|
|
// FIXME: todo
|
|
}
|
|
|
|
#[test]
|
|
fn test_vis() {
|
|
// VisibilityKind::Public
|
|
c2!(vis, [ pub ], "pub ", "pub");
|
|
|
|
// VisibilityKind::Restricted
|
|
c2!(vis, [ pub(crate) ], "pub(crate) ", "pub(crate)");
|
|
c2!(vis, [ pub(self) ], "pub(self) ", "pub(self)");
|
|
c2!(vis, [ pub(super) ], "pub(super) ", "pub(super)");
|
|
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 super::path::to) ],
|
|
"pub(in super::path::to) ",
|
|
"pub(in super::path::to)"
|
|
);
|
|
|
|
// VisibilityKind::Inherited
|
|
// This one is different because directly calling `vis!` does not work.
|
|
macro_rules! inherited_vis { ($vis:vis struct) => { vis!($vis) }; }
|
|
assert_eq!(inherited_vis!(struct), "");
|
|
assert_eq!(stringify!(), "");
|
|
}
|
|
|
|
macro_rules! p {
|
|
([$($tt:tt)*], $s:literal) => {
|
|
assert_eq!(stringify!($($tt)*), $s);
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_punct() {
|
|
// 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!([ = = < < <= <= == == != != >= >= > > ], "= = < < <= <= == == != != >= >= > >");
|
|
p!([ && && & & || || | | ! ! ], "&& && & & || || | | ! !");
|
|
p!([ ~ ~ @ @ # # ], "~ ~ @ @ # #");
|
|
p!([ . . .. .. ... ... ..= ..=], ". . .. .. ... ... ..= ..=");
|
|
p!([ , , ; ; : : :: :: ], ", , ; ; : : :: ::");
|
|
p!([ -> -> <- <- => =>], "-> -> <- <- => =>");
|
|
p!([ $ $ ? ? ' ' ], "$ $ ? ? ' '");
|
|
p!([ + + += += - - -= -= * * *= *= / / /= /= ], "+ + += += - - -= -= * * *= *= / / /= /=");
|
|
p!([ % % %= %= ^ ^ ^= ^= << << <<= <<= >> >> >>= >>= ],
|
|
"% % %= %= ^ ^ ^= ^= << << <<= <<= >> >> >>= >>=");
|
|
p!([ +! ?= |> >>@ --> <-- $$ =====> ], "+! ?= |> >>@ --> <-- $$ =====>");
|
|
p!([ ,; ;, ** @@ $+$ >< <> ?? +== ], ",; ;, ** @@ $+$ >< <> ?? +==");
|
|
p!([ :#!@|$=&*,+;*~? ], ":#!@|$=&*,+;*~?");
|
|
}
|