diff options
Diffstat (limited to 'src/test/ui/macros/stringify.rs')
| -rw-r--r-- | src/test/ui/macros/stringify.rs | 889 |
1 files changed, 0 insertions, 889 deletions
diff --git a/src/test/ui/macros/stringify.rs b/src/test/ui/macros/stringify.rs deleted file mode 100644 index 5cd217df6fc..00000000000 --- a/src/test/ui/macros/stringify.rs +++ /dev/null @@ -1,889 +0,0 @@ -// run-pass -// edition:2021 -// compile-flags: --test - -#![feature(async_closure)] -#![feature(box_patterns)] -#![feature(box_syntax)] -#![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::Box - assert_eq!(stringify_expr!(box expr), "box 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 - assert_eq!(stringify_expr!(expr: T), "expr: T"); - assert_eq!(stringify_expr!(expr: T<u8>), "expr: T<u8>"); - - // 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 Struct {}", // FIXME - ); - - // 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 Clone"); // FIXME - 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 Clone"); // FIXME - 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), ""); -} |