| // run-pass |
| // edition:2021 |
| // compile-flags: --test |
| |
| #![feature(async_closure)] |
| #![feature(box_patterns)] |
| #![feature(const_trait_impl)] |
| #![feature(decl_macro)] |
| #![feature(generators)] |
| #![feature(more_qualified_paths)] |
| #![feature(raw_ref_op)] |
| #![feature(trait_alias)] |
| #![feature(try_blocks)] |
| #![feature(type_ascription)] |
| #![deny(unused_macros)] |
| |
| macro_rules! stringify_block { |
| ($block:block) => { |
| stringify!($block) |
| }; |
| } |
| |
| macro_rules! stringify_expr { |
| ($expr:expr) => { |
| stringify!($expr) |
| }; |
| } |
| |
| macro_rules! stringify_item { |
| ($item:item) => { |
| stringify!($item) |
| }; |
| } |
| |
| macro_rules! stringify_meta { |
| ($meta:meta) => { |
| stringify!($meta) |
| }; |
| } |
| |
| macro_rules! stringify_pat { |
| ($pat:pat) => { |
| stringify!($pat) |
| }; |
| } |
| |
| macro_rules! stringify_path { |
| ($path:path) => { |
| stringify!($path) |
| }; |
| } |
| |
| macro_rules! stringify_stmt { |
| ($stmt:stmt) => { |
| stringify!($stmt) |
| }; |
| } |
| |
| macro_rules! stringify_ty { |
| ($ty:ty) => { |
| stringify!($ty) |
| }; |
| } |
| |
| macro_rules! stringify_vis { |
| ($vis:vis) => { |
| stringify!($vis) |
| }; |
| } |
| |
| #[test] |
| fn test_block() { |
| assert_eq!(stringify_block!({}), "{}"); |
| assert_eq!(stringify_block!({ true }), "{ true }"); |
| assert_eq!(stringify_block!({ return }), "{ return }"); |
| assert_eq!( |
| stringify_block!({ |
| return; |
| }), |
| "{ return; }", |
| ); |
| assert_eq!( |
| stringify_block!({ |
| let _; |
| true |
| }), |
| "{ let _; true }", |
| ); |
| } |
| |
| #[test] |
| fn test_expr() { |
| // ExprKind::Array |
| assert_eq!(stringify_expr!([]), "[]"); |
| assert_eq!(stringify_expr!([true]), "[true]"); |
| assert_eq!(stringify_expr!([true,]), "[true]"); |
| assert_eq!(stringify_expr!([true, true]), "[true, true]"); |
| |
| // ExprKind::Call |
| assert_eq!(stringify_expr!(f()), "f()"); |
| assert_eq!(stringify_expr!(f::<u8>()), "f::<u8>()"); |
| assert_eq!(stringify_expr!(f::<1>()), "f::<1>()"); |
| assert_eq!(stringify_expr!(f::<'a, u8, 1>()), "f::<'a, u8, 1>()"); |
| assert_eq!(stringify_expr!(f(true)), "f(true)"); |
| assert_eq!(stringify_expr!(f(true,)), "f(true)"); |
| assert_eq!(stringify_expr!(()()), "()()"); |
| |
| // ExprKind::MethodCall |
| assert_eq!(stringify_expr!(x.f()), "x.f()"); |
| assert_eq!(stringify_expr!(x.f::<u8>()), "x.f::<u8>()"); |
| |
| // ExprKind::Tup |
| assert_eq!(stringify_expr!(()), "()"); |
| assert_eq!(stringify_expr!((true,)), "(true,)"); |
| assert_eq!(stringify_expr!((true, false)), "(true, false)"); |
| assert_eq!(stringify_expr!((true, false,)), "(true, false)"); |
| |
| // ExprKind::Binary |
| assert_eq!(stringify_expr!(true || false), "true || false"); |
| assert_eq!(stringify_expr!(true || false && false), "true || false && false"); |
| |
| // ExprKind::Unary |
| assert_eq!(stringify_expr!(*expr), "*expr"); |
| assert_eq!(stringify_expr!(!expr), "!expr"); |
| assert_eq!(stringify_expr!(-expr), "-expr"); |
| |
| // ExprKind::Lit |
| assert_eq!(stringify_expr!('x'), "'x'"); |
| assert_eq!(stringify_expr!(1_000_i8), "1_000_i8"); |
| assert_eq!(stringify_expr!(1.00000000000000001), "1.00000000000000001"); |
| |
| // ExprKind::Cast |
| assert_eq!(stringify_expr!(expr as T), "expr as T"); |
| assert_eq!(stringify_expr!(expr as T<u8>), "expr as T<u8>"); |
| |
| // ExprKind::Type |
| // There is no syntax for type ascription. |
| |
| // ExprKind::If |
| assert_eq!(stringify_expr!(if true {}), "if true {}"); |
| assert_eq!( |
| stringify_expr!(if true { |
| } else { |
| }), |
| "if true {} else {}", |
| ); |
| assert_eq!( |
| stringify_expr!(if let true = true { |
| } else { |
| }), |
| "if let true = true {} else {}", |
| ); |
| assert_eq!( |
| stringify_expr!(if true { |
| } else if false { |
| }), |
| "if true {} else if false {}", |
| ); |
| assert_eq!( |
| stringify_expr!(if true { |
| } else if false { |
| } else { |
| }), |
| "if true {} else if false {} else {}", |
| ); |
| assert_eq!( |
| stringify_expr!(if true { |
| return; |
| } else if false { |
| 0 |
| } else { |
| 0 |
| }), |
| "if true { return; } else if false { 0 } else { 0 }", |
| ); |
| |
| // ExprKind::While |
| assert_eq!(stringify_expr!(while true {}), "while true {}"); |
| assert_eq!(stringify_expr!('a: while true {}), "'a: while true {}"); |
| assert_eq!(stringify_expr!(while let true = true {}), "while let true = true {}"); |
| |
| // ExprKind::ForLoop |
| assert_eq!(stringify_expr!(for _ in x {}), "for _ in x {}"); |
| assert_eq!(stringify_expr!('a: for _ in x {}), "'a: for _ in x {}"); |
| |
| // ExprKind::Loop |
| assert_eq!(stringify_expr!(loop {}), "loop {}"); |
| assert_eq!(stringify_expr!('a: loop {}), "'a: loop {}"); |
| |
| // ExprKind::Match |
| assert_eq!(stringify_expr!(match self {}), "match self {}"); |
| assert_eq!( |
| stringify_expr!(match self { |
| Ok => 1, |
| }), |
| "match self { Ok => 1, }", |
| ); |
| assert_eq!( |
| stringify_expr!(match self { |
| Ok => 1, |
| Err => 0, |
| }), |
| "match self { Ok => 1, Err => 0, }", |
| ); |
| |
| // ExprKind::Closure |
| assert_eq!(stringify_expr!(|| {}), "|| {}"); |
| assert_eq!(stringify_expr!(|x| {}), "|x| {}"); |
| assert_eq!(stringify_expr!(|x: u8| {}), "|x: u8| {}"); |
| assert_eq!(stringify_expr!(|| ()), "|| ()"); |
| assert_eq!(stringify_expr!(move || self), "move || self"); |
| assert_eq!(stringify_expr!(async || self), "async || self"); |
| assert_eq!(stringify_expr!(async move || self), "async move || self"); |
| assert_eq!(stringify_expr!(static || self), "static || self"); |
| assert_eq!(stringify_expr!(static move || self), "static move || self"); |
| #[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/5149 |
| assert_eq!( |
| stringify_expr!(static async || self), |
| "static async || self", |
| ); |
| #[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/5149 |
| assert_eq!( |
| stringify_expr!(static async move || self), |
| "static async move || self", |
| ); |
| assert_eq!(stringify_expr!(|| -> u8 { self }), "|| -> u8 { self }"); |
| assert_eq!(stringify_expr!(1 + || {}), "1 + (|| {})"); // ?? |
| |
| // ExprKind::Block |
| assert_eq!(stringify_expr!({}), "{}"); |
| assert_eq!(stringify_expr!(unsafe {}), "unsafe {}"); |
| assert_eq!(stringify_expr!('a: {}), "'a: {}"); |
| assert_eq!( |
| stringify_expr!( |
| #[attr] |
| {} |
| ), |
| "#[attr] {}", |
| ); |
| assert_eq!( |
| stringify_expr!( |
| { |
| #![attr] |
| } |
| ), |
| "{\n\ |
| \x20 #![attr]\n\ |
| }", |
| ); |
| |
| // ExprKind::Async |
| assert_eq!(stringify_expr!(async {}), "async {}"); |
| assert_eq!(stringify_expr!(async move {}), "async move {}"); |
| |
| // ExprKind::Await |
| assert_eq!(stringify_expr!(expr.await), "expr.await"); |
| |
| // ExprKind::TryBlock |
| assert_eq!(stringify_expr!(try {}), "try {}"); |
| |
| // ExprKind::Assign |
| assert_eq!(stringify_expr!(expr = true), "expr = true"); |
| |
| // ExprKind::AssignOp |
| assert_eq!(stringify_expr!(expr += true), "expr += true"); |
| |
| // ExprKind::Field |
| assert_eq!(stringify_expr!(expr.field), "expr.field"); |
| assert_eq!(stringify_expr!(expr.0), "expr.0"); |
| |
| // ExprKind::Index |
| assert_eq!(stringify_expr!(expr[true]), "expr[true]"); |
| |
| // ExprKind::Range |
| assert_eq!(stringify_expr!(..), ".."); |
| assert_eq!(stringify_expr!(..hi), "..hi"); |
| assert_eq!(stringify_expr!(lo..), "lo.."); |
| assert_eq!(stringify_expr!(lo..hi), "lo..hi"); |
| assert_eq!(stringify_expr!(..=hi), "..=hi"); |
| assert_eq!(stringify_expr!(lo..=hi), "lo..=hi"); |
| assert_eq!(stringify_expr!(-2..=-1), "-2..=-1"); |
| |
| // ExprKind::Path |
| assert_eq!(stringify_expr!(thing), "thing"); |
| assert_eq!(stringify_expr!(m::thing), "m::thing"); |
| assert_eq!(stringify_expr!(self::thing), "self::thing"); |
| assert_eq!(stringify_expr!(crate::thing), "crate::thing"); |
| assert_eq!(stringify_expr!(Self::thing), "Self::thing"); |
| assert_eq!(stringify_expr!(<Self as T>::thing), "<Self as T>::thing"); |
| assert_eq!(stringify_expr!(Self::<'static>), "Self::<'static>"); |
| |
| // ExprKind::AddrOf |
| assert_eq!(stringify_expr!(&expr), "&expr"); |
| assert_eq!(stringify_expr!(&mut expr), "&mut expr"); |
| assert_eq!(stringify_expr!(&raw const expr), "&raw const expr"); |
| assert_eq!(stringify_expr!(&raw mut expr), "&raw mut expr"); |
| |
| // ExprKind::Break |
| assert_eq!(stringify_expr!(break), "break"); |
| assert_eq!(stringify_expr!(break 'a), "break 'a"); |
| assert_eq!(stringify_expr!(break true), "break true"); |
| assert_eq!(stringify_expr!(break 'a true), "break 'a true"); |
| |
| // ExprKind::Continue |
| assert_eq!(stringify_expr!(continue), "continue"); |
| assert_eq!(stringify_expr!(continue 'a), "continue 'a"); |
| |
| // ExprKind::Ret |
| assert_eq!(stringify_expr!(return), "return"); |
| assert_eq!(stringify_expr!(return true), "return true"); |
| |
| // ExprKind::MacCall |
| assert_eq!(stringify_expr!(mac!(...)), "mac!(...)"); |
| assert_eq!(stringify_expr!(mac![...]), "mac![...]"); |
| assert_eq!(stringify_expr!(mac! { ... }), "mac! { ... }"); |
| |
| // ExprKind::Struct |
| assert_eq!(stringify_expr!(Struct {}), "Struct {}"); |
| #[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/5151 |
| assert_eq!(stringify_expr!(<Struct as Trait>::Type {}), "<Struct as Trait>::Type {}"); |
| assert_eq!(stringify_expr!(Struct { .. }), "Struct { .. }"); |
| assert_eq!(stringify_expr!(Struct { ..base }), "Struct { ..base }"); |
| assert_eq!(stringify_expr!(Struct { x }), "Struct { x }"); |
| assert_eq!(stringify_expr!(Struct { x, .. }), "Struct { x, .. }"); |
| assert_eq!(stringify_expr!(Struct { x, ..base }), "Struct { x, ..base }"); |
| assert_eq!(stringify_expr!(Struct { x: true }), "Struct { x: true }"); |
| assert_eq!(stringify_expr!(Struct { x: true, .. }), "Struct { x: true, .. }"); |
| assert_eq!(stringify_expr!(Struct { x: true, ..base }), "Struct { x: true, ..base }"); |
| |
| // ExprKind::Repeat |
| assert_eq!(stringify_expr!([(); 0]), "[(); 0]"); |
| |
| // ExprKind::Paren |
| assert_eq!(stringify_expr!((expr)), "(expr)"); |
| |
| // ExprKind::Try |
| assert_eq!(stringify_expr!(expr?), "expr?"); |
| |
| // ExprKind::Yield |
| assert_eq!(stringify_expr!(yield), "yield"); |
| assert_eq!(stringify_expr!(yield true), "yield true"); |
| } |
| |
| #[test] |
| fn test_item() { |
| // ItemKind::ExternCrate |
| assert_eq!( |
| stringify_item!( |
| extern crate std; |
| ), |
| "extern crate std;", |
| ); |
| assert_eq!( |
| stringify_item!( |
| pub extern crate self as std; |
| ), |
| "pub extern crate self as std;", |
| ); |
| |
| // ItemKind::Use |
| assert_eq!( |
| stringify_item!( |
| pub use crate::{a, b::c}; |
| ), |
| "pub use crate::{a, b::c};", |
| ); |
| |
| // ItemKind::Static |
| assert_eq!( |
| stringify_item!( |
| pub static S: () = {}; |
| ), |
| "pub static S: () = {};", |
| ); |
| assert_eq!( |
| stringify_item!( |
| static mut S: () = {}; |
| ), |
| "static mut S: () = {};", |
| ); |
| assert_eq!( |
| stringify_item!( |
| static S: (); |
| ), |
| "static S: ();", |
| ); |
| assert_eq!( |
| stringify_item!( |
| static mut S: (); |
| ), |
| "static mut S: ();", |
| ); |
| |
| // ItemKind::Const |
| assert_eq!( |
| stringify_item!( |
| pub const S: () = {}; |
| ), |
| "pub const S: () = {};", |
| ); |
| assert_eq!( |
| stringify_item!( |
| const S: (); |
| ), |
| "const S: ();", |
| ); |
| |
| // ItemKind::Fn |
| assert_eq!( |
| stringify_item!( |
| pub default const async unsafe extern "C" fn f() {} |
| ), |
| "pub default const async unsafe extern \"C\" fn f() {}", |
| ); |
| |
| // ItemKind::Mod |
| assert_eq!( |
| stringify_item!( |
| pub mod m; |
| ), |
| "pub mod m;", |
| ); |
| assert_eq!( |
| stringify_item!( |
| mod m {} |
| ), |
| "mod m {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| unsafe mod m; |
| ), |
| "unsafe mod m;", |
| ); |
| assert_eq!( |
| stringify_item!( |
| unsafe mod m {} |
| ), |
| "unsafe mod m {}", |
| ); |
| |
| // ItemKind::ForeignMod |
| assert_eq!( |
| stringify_item!( |
| extern "C" {} |
| ), |
| "extern \"C\" {}", |
| ); |
| #[rustfmt::skip] |
| assert_eq!( |
| stringify_item!( |
| pub extern "C" {} |
| ), |
| "extern \"C\" {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| unsafe extern "C++" {} |
| ), |
| "unsafe extern \"C++\" {}", |
| ); |
| |
| // ItemKind::TyAlias |
| #[rustfmt::skip] |
| assert_eq!( |
| stringify_item!( |
| pub default type Type<'a>: Bound |
| where |
| Self: 'a, |
| = T; |
| ), |
| "pub default type Type<'a>: Bound where Self: 'a = T;", |
| ); |
| |
| // ItemKind::Enum |
| assert_eq!( |
| stringify_item!( |
| pub enum Void {} |
| ), |
| "pub enum Void {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| enum Empty { |
| Unit, |
| Tuple(), |
| Struct {}, |
| } |
| ), |
| "enum Empty { Unit, Tuple(), Struct {}, }", |
| ); |
| assert_eq!( |
| stringify_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\ |
| }", |
| ); |
| |
| // ItemKind::Struct |
| assert_eq!( |
| stringify_item!( |
| pub struct Unit; |
| ), |
| "pub struct Unit;", |
| ); |
| assert_eq!( |
| stringify_item!( |
| struct Tuple(); |
| ), |
| "struct Tuple();", |
| ); |
| assert_eq!( |
| stringify_item!( |
| struct Tuple(T); |
| ), |
| "struct Tuple(T);", |
| ); |
| assert_eq!( |
| stringify_item!( |
| struct Struct {} |
| ), |
| "struct Struct {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| struct Struct<T> |
| where |
| T: 'a, |
| { |
| t: T, |
| } |
| ), |
| "struct Struct<T> where T: 'a {\n\ |
| \x20 t: T,\n\ |
| }", |
| ); |
| |
| // ItemKind::Union |
| assert_eq!( |
| stringify_item!( |
| pub union Union {} |
| ), |
| "pub union Union {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| union Union<T> where T: 'a { |
| t: T, |
| } |
| ), |
| "union Union<T> where T: 'a {\n\ |
| \x20 t: T,\n\ |
| }", |
| ); |
| |
| // ItemKind::Trait |
| assert_eq!( |
| stringify_item!( |
| pub unsafe auto trait Send {} |
| ), |
| "pub unsafe auto trait Send {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| trait Trait<'a>: Sized |
| where |
| Self: 'a, |
| { |
| } |
| ), |
| "trait Trait<'a>: Sized where Self: 'a {}", |
| ); |
| |
| // ItemKind::TraitAlias |
| assert_eq!( |
| stringify_item!( |
| pub trait Trait<T> = Sized where T: 'a; |
| ), |
| "pub trait Trait<T> = Sized where T: 'a;", |
| ); |
| |
| // ItemKind::Impl |
| assert_eq!( |
| stringify_item!( |
| pub impl Struct {} |
| ), |
| "pub impl Struct {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| impl<T> Struct<T> {} |
| ), |
| "impl<T> Struct<T> {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| pub impl Trait for Struct {} |
| ), |
| "pub impl Trait for Struct {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| impl<T> const Trait for T {} |
| ), |
| "impl<T> const Trait for T {}", |
| ); |
| assert_eq!( |
| stringify_item!( |
| impl ~const Struct {} |
| ), |
| "impl ~const Struct {}", |
| ); |
| |
| // ItemKind::MacCall |
| assert_eq!(stringify_item!(mac!(...);), "mac!(...);"); |
| assert_eq!(stringify_item!(mac![...];), "mac![...];"); |
| assert_eq!(stringify_item!(mac! { ... }), "mac! { ... }"); |
| |
| // ItemKind::MacroDef |
| assert_eq!( |
| stringify_item!( |
| macro_rules! stringify { |
| () => {}; |
| } |
| ), |
| "macro_rules! stringify { () => {} ; }", // FIXME |
| ); |
| assert_eq!( |
| stringify_item!( |
| pub macro stringify() {} |
| ), |
| "pub macro stringify { () => {} }", |
| ); |
| } |
| |
| #[test] |
| fn test_meta() { |
| assert_eq!(stringify_meta!(k), "k"); |
| assert_eq!(stringify_meta!(k = "v"), "k = \"v\""); |
| assert_eq!(stringify_meta!(list(k1, k2 = "v")), "list(k1, k2 = \"v\")"); |
| assert_eq!(stringify_meta!(serde::k), "serde::k"); |
| } |
| |
| #[test] |
| fn test_pat() { |
| // PatKind::Wild |
| assert_eq!(stringify_pat!(_), "_"); |
| |
| // PatKind::Ident |
| assert_eq!(stringify_pat!(_x), "_x"); |
| assert_eq!(stringify_pat!(ref _x), "ref _x"); |
| assert_eq!(stringify_pat!(mut _x), "mut _x"); |
| assert_eq!(stringify_pat!(ref mut _x), "ref mut _x"); |
| assert_eq!(stringify_pat!(ref mut _x @ _), "ref mut _x @ _"); |
| |
| // PatKind::Struct |
| assert_eq!(stringify_pat!(Struct {}), "Struct {}"); |
| assert_eq!(stringify_pat!(Struct::<u8> {}), "Struct::<u8> {}"); |
| assert_eq!(stringify_pat!(Struct::<'static> {}), "Struct::<'static> {}"); |
| assert_eq!(stringify_pat!(Struct { x }), "Struct { x }"); |
| assert_eq!(stringify_pat!(Struct { x: _x }), "Struct { x: _x }"); |
| assert_eq!(stringify_pat!(Struct { .. }), "Struct { .. }"); |
| assert_eq!(stringify_pat!(Struct { x, .. }), "Struct { x, .. }"); |
| assert_eq!(stringify_pat!(Struct { x: _x, .. }), "Struct { x: _x, .. }"); |
| #[rustfmt::skip] // https://github.com/rust-lang/rustfmt/issues/5151 |
| assert_eq!( |
| stringify_pat!(<Struct as Trait>::Type {}), |
| "<Struct as Trait>::Type {}", |
| ); |
| |
| // PatKind::TupleStruct |
| assert_eq!(stringify_pat!(Tuple()), "Tuple()"); |
| assert_eq!(stringify_pat!(Tuple::<u8>()), "Tuple::<u8>()"); |
| assert_eq!(stringify_pat!(Tuple::<'static>()), "Tuple::<'static>()"); |
| assert_eq!(stringify_pat!(Tuple(x)), "Tuple(x)"); |
| assert_eq!(stringify_pat!(Tuple(..)), "Tuple(..)"); |
| assert_eq!(stringify_pat!(Tuple(x, ..)), "Tuple(x, ..)"); |
| assert_eq!(stringify_pat!(<Struct as Trait>::Type()), "<Struct as Trait>::Type()"); |
| |
| // PatKind::Or |
| assert_eq!(stringify_pat!(true | false), "true | false"); |
| assert_eq!(stringify_pat!(| true), "true"); |
| assert_eq!(stringify_pat!(|true| false), "true | false"); |
| |
| // PatKind::Path |
| assert_eq!(stringify_pat!(crate::Path), "crate::Path"); |
| assert_eq!(stringify_pat!(Path::<u8>), "Path::<u8>"); |
| assert_eq!(stringify_pat!(Path::<'static>), "Path::<'static>"); |
| assert_eq!(stringify_pat!(<Struct as Trait>::Type), "<Struct as Trait>::Type"); |
| |
| // PatKind::Tuple |
| assert_eq!(stringify_pat!(()), "()"); |
| assert_eq!(stringify_pat!((true,)), "(true,)"); |
| assert_eq!(stringify_pat!((true, false)), "(true, false)"); |
| |
| // PatKind::Box |
| assert_eq!(stringify_pat!(box pat), "box pat"); |
| |
| // PatKind::Ref |
| assert_eq!(stringify_pat!(&pat), "&pat"); |
| assert_eq!(stringify_pat!(&mut pat), "&mut pat"); |
| |
| // PatKind::Lit |
| assert_eq!(stringify_pat!(1_000_i8), "1_000_i8"); |
| |
| // PatKind::Range |
| assert_eq!(stringify_pat!(..1), "..1"); |
| assert_eq!(stringify_pat!(0..), "0.."); |
| assert_eq!(stringify_pat!(0..1), "0..1"); |
| assert_eq!(stringify_pat!(0..=1), "0..=1"); |
| assert_eq!(stringify_pat!(-2..=-1), "-2..=-1"); |
| |
| // PatKind::Slice |
| assert_eq!(stringify_pat!([]), "[]"); |
| assert_eq!(stringify_pat!([true]), "[true]"); |
| assert_eq!(stringify_pat!([true,]), "[true]"); |
| assert_eq!(stringify_pat!([true, false]), "[true, false]"); |
| |
| // PatKind::Rest |
| assert_eq!(stringify_pat!(..), ".."); |
| |
| // PatKind::Paren |
| assert_eq!(stringify_pat!((pat)), "(pat)"); |
| |
| // PatKind::MacCall |
| assert_eq!(stringify_pat!(mac!(...)), "mac!(...)"); |
| assert_eq!(stringify_pat!(mac![...]), "mac![...]"); |
| assert_eq!(stringify_pat!(mac! { ... }), "mac! { ... }"); |
| } |
| |
| #[test] |
| fn test_path() { |
| assert_eq!(stringify_path!(thing), "thing"); |
| assert_eq!(stringify_path!(m::thing), "m::thing"); |
| assert_eq!(stringify_path!(self::thing), "self::thing"); |
| assert_eq!(stringify_path!(crate::thing), "crate::thing"); |
| assert_eq!(stringify_path!(Self::thing), "Self::thing"); |
| assert_eq!(stringify_path!(Self<'static>), "Self<'static>"); |
| assert_eq!(stringify_path!(Self::<'static>), "Self<'static>"); |
| assert_eq!(stringify_path!(Self()), "Self()"); |
| assert_eq!(stringify_path!(Self() -> ()), "Self() -> ()"); |
| } |
| |
| #[test] |
| fn test_stmt() { |
| // StmtKind::Local |
| assert_eq!(stringify_stmt!(let _), "let _;"); |
| assert_eq!(stringify_stmt!(let x = true), "let x = true;"); |
| assert_eq!(stringify_stmt!(let x: bool = true), "let x: bool = true;"); |
| |
| // StmtKind::Item |
| assert_eq!( |
| stringify_stmt!( |
| struct S; |
| ), |
| "struct S;", |
| ); |
| |
| // StmtKind::Expr |
| assert_eq!(stringify_stmt!(loop {}), "loop {}"); |
| |
| // StmtKind::Semi |
| assert_eq!(stringify_stmt!(1 + 1), "1 + 1;"); |
| |
| // StmtKind::Empty |
| assert_eq!(stringify_stmt!(;), ";"); |
| |
| // StmtKind::MacCall |
| assert_eq!(stringify_stmt!(mac!(...)), "mac!(...)"); |
| assert_eq!(stringify_stmt!(mac![...]), "mac![...]"); |
| assert_eq!(stringify_stmt!(mac! { ... }), "mac! { ... }"); |
| } |
| |
| #[test] |
| fn test_ty() { |
| // TyKind::Slice |
| assert_eq!(stringify_ty!([T]), "[T]"); |
| |
| // TyKind::Array |
| assert_eq!(stringify_ty!([T; 0]), "[T; 0]"); |
| |
| // TyKind::Ptr |
| assert_eq!(stringify_ty!(*const T), "*const T"); |
| assert_eq!(stringify_ty!(*mut T), "*mut T"); |
| |
| // TyKind::Ref |
| assert_eq!(stringify_ty!(&T), "&T"); |
| assert_eq!(stringify_ty!(&mut T), "&mut T"); |
| assert_eq!(stringify_ty!(&'a T), "&'a T"); |
| assert_eq!(stringify_ty!(&'a mut T), "&'a mut T"); |
| |
| // TyKind::BareFn |
| assert_eq!(stringify_ty!(fn()), "fn()"); |
| assert_eq!(stringify_ty!(fn() -> ()), "fn() -> ()"); |
| assert_eq!(stringify_ty!(fn(u8)), "fn(u8)"); |
| assert_eq!(stringify_ty!(fn(x: u8)), "fn(x: u8)"); |
| #[rustfmt::skip] |
| assert_eq!(stringify_ty!(for<> fn()), "fn()"); |
| assert_eq!(stringify_ty!(for<'a> fn()), "for<'a> fn()"); |
| |
| // TyKind::Never |
| assert_eq!(stringify_ty!(!), "!"); |
| |
| // TyKind::Tup |
| assert_eq!(stringify_ty!(()), "()"); |
| assert_eq!(stringify_ty!((T,)), "(T,)"); |
| assert_eq!(stringify_ty!((T, U)), "(T, U)"); |
| |
| // TyKind::Path |
| assert_eq!(stringify_ty!(T), "T"); |
| assert_eq!(stringify_ty!(Ref<'a>), "Ref<'a>"); |
| assert_eq!(stringify_ty!(PhantomData<T>), "PhantomData<T>"); |
| assert_eq!(stringify_ty!(PhantomData::<T>), "PhantomData<T>"); |
| assert_eq!(stringify_ty!(Fn() -> !), "Fn() -> !"); |
| assert_eq!(stringify_ty!(Fn(u8) -> !), "Fn(u8) -> !"); |
| assert_eq!(stringify_ty!(<Struct as Trait>::Type), "<Struct as Trait>::Type"); |
| |
| // TyKind::TraitObject |
| assert_eq!(stringify_ty!(dyn Send), "dyn Send"); |
| assert_eq!(stringify_ty!(dyn Send + 'a), "dyn Send + 'a"); |
| assert_eq!(stringify_ty!(dyn 'a + Send), "dyn 'a + Send"); |
| assert_eq!(stringify_ty!(dyn ?Sized), "dyn ?Sized"); |
| assert_eq!(stringify_ty!(dyn ~const Clone), "dyn ~const Clone"); |
| assert_eq!(stringify_ty!(dyn for<'a> Send), "dyn for<'a> Send"); |
| |
| // TyKind::ImplTrait |
| assert_eq!(stringify_ty!(impl Send), "impl Send"); |
| assert_eq!(stringify_ty!(impl Send + 'a), "impl Send + 'a"); |
| assert_eq!(stringify_ty!(impl 'a + Send), "impl 'a + Send"); |
| assert_eq!(stringify_ty!(impl ?Sized), "impl ?Sized"); |
| assert_eq!(stringify_ty!(impl ~const Clone), "impl ~const Clone"); |
| assert_eq!(stringify_ty!(impl for<'a> Send), "impl for<'a> Send"); |
| |
| // TyKind::Paren |
| assert_eq!(stringify_ty!((T)), "(T)"); |
| |
| // TyKind::Infer |
| assert_eq!(stringify_ty!(_), "_"); |
| |
| // TyKind::MacCall |
| assert_eq!(stringify_ty!(mac!(...)), "mac!(...)"); |
| assert_eq!(stringify_ty!(mac![...]), "mac![...]"); |
| assert_eq!(stringify_ty!(mac! { ... }), "mac! { ... }"); |
| } |
| |
| #[test] |
| fn test_vis() { |
| // VisibilityKind::Public |
| assert_eq!(stringify_vis!(pub), "pub "); |
| |
| // VisibilityKind::Restricted |
| assert_eq!(stringify_vis!(pub(crate)), "pub(crate) "); |
| assert_eq!(stringify_vis!(pub(self)), "pub(self) "); |
| assert_eq!(stringify_vis!(pub(super)), "pub(super) "); |
| assert_eq!(stringify_vis!(pub(in crate)), "pub(in crate) "); |
| assert_eq!(stringify_vis!(pub(in self)), "pub(in self) "); |
| assert_eq!(stringify_vis!(pub(in super)), "pub(in super) "); |
| assert_eq!(stringify_vis!(pub(in path::to)), "pub(in path::to) "); |
| assert_eq!(stringify_vis!(pub(in ::path::to)), "pub(in ::path::to) "); |
| assert_eq!(stringify_vis!(pub(in self::path::to)), "pub(in self::path::to) "); |
| assert_eq!(stringify_vis!(pub(in super::path::to)), "pub(in super::path::to) "); |
| |
| // VisibilityKind::Inherited |
| // Directly calling `stringify_vis!()` does not work. |
| macro_rules! stringify_inherited_vis { |
| ($vis:vis struct) => { |
| stringify_vis!($vis) |
| }; |
| } |
| assert_eq!(stringify_inherited_vis!(struct), ""); |
| } |
