nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-16 05:56:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format core and std macro rules, removing needless surrounding blocks

Browse Source
This commit is contained in:
David Tolnay 2022-03-09 21:30:52 -08:00
parent 335ffbfa54
commit af53809c87
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
6 changed files with 72 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
library/core/src/macros/mod.rs
View File

@ -34,7 +34,7 @@ macro_rules! panic {
#[cfg_attr(not(test), rustc_diagnostic_item = "assert_eq_macro")]
#[allow_internal_unstable(core_panic)]
macro_rules! assert_eq {
($left:expr, $right:expr $(,)?) => ({
($left:expr, $right:expr $(,)?) => {
match (&$left, &$right) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
@ -46,8 +46,8 @@ macro_rules! assert_eq {
}
}
}
});
($left:expr, $right:expr, $($arg:tt)+) => ({
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&$left, &$right) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
@ -59,7 +59,7 @@ macro_rules! assert_eq {
}
}
}
});
};
}
/// Asserts that two expressions are not equal to each other (using [`PartialEq`]).
@ -84,7 +84,7 @@ macro_rules! assert_eq {
#[cfg_attr(not(test), rustc_diagnostic_item = "assert_ne_macro")]
#[allow_internal_unstable(core_panic)]
macro_rules! assert_ne {
($left:expr, $right:expr $(,)?) => ({
($left:expr, $right:expr $(,)?) => {
match (&$left, &$right) {
(left_val, right_val) => {
if *left_val == *right_val {
@ -96,8 +96,8 @@ macro_rules! assert_ne {
}
}
}
});
($left:expr, $right:expr, $($arg:tt)+) => ({
};
($left:expr, $right:expr, $($arg:tt)+) => {
match (&($left), &($right)) {
(left_val, right_val) => {
if *left_val == *right_val {
@ -109,7 +109,7 @@ macro_rules! assert_ne {
}
}
}
});
};
}
/// Asserts that an expression matches any of the given patterns.
@ -142,7 +142,7 @@ macro_rules! assert_ne {
#[allow_internal_unstable(core_panic)]
#[rustc_macro_transparency = "semitransparent"]
pub macro assert_matches {
($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => ({
($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => {
match $left {
$( $pattern )|+ $( if $guard )? => {}
ref left_val => {
@ -153,8 +153,8 @@ pub macro assert_matches {
);
}
}
}),
($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )?, $($arg:tt)+) => ({
},
($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )?, $($arg:tt)+) => {
match $left {
$( $pattern )|+ $( if $guard )? => {}
ref left_val => {
@ -165,7 +165,7 @@ pub macro assert_matches {
);
}
}
}),
},
}
/// Asserts that a boolean expression is `true` at runtime.
@ -214,7 +214,11 @@ pub macro assert_matches {
#[rustc_diagnostic_item = "debug_assert_macro"]
#[allow_internal_unstable(edition_panic)]
macro_rules! debug_assert {
($($arg:tt)*) => (if $crate::cfg!(debug_assertions) { $crate::assert!($($arg)*); })
($($arg:tt)*) => {
if $crate::cfg!(debug_assertions) {
$crate::assert!($($arg)*);
}
};
}
/// Asserts that two expressions are equal to each other.
@ -240,7 +244,11 @@ macro_rules! debug_assert {
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_eq_macro")]
macro_rules! debug_assert_eq {
($($arg:tt)*) => (if $crate::cfg!(debug_assertions) { $crate::assert_eq!($($arg)*); })
($($arg:tt)*) => {
if $crate::cfg!(debug_assertions) {
$crate::assert_eq!($($arg)*);
}
};
}
/// Asserts that two expressions are not equal to each other.
@ -266,7 +274,11 @@ macro_rules! debug_assert_eq {
#[stable(feature = "assert_ne", since = "1.13.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_ne_macro")]
macro_rules! debug_assert_ne {
($($arg:tt)*) => (if $crate::cfg!(debug_assertions) { $crate::assert_ne!($($arg)*); })
($($arg:tt)*) => {
if $crate::cfg!(debug_assertions) {
$crate::assert_ne!($($arg)*);
}
};
}
/// Asserts that an expression matches any of the given patterns.
@ -305,7 +317,9 @@ macro_rules! debug_assert_ne {
#[allow_internal_unstable(assert_matches)]
#[rustc_macro_transparency = "semitransparent"]
pub macro debug_assert_matches($($arg:tt)*) {
if $crate::cfg!(debug_assertions) { $crate::assert_matches::assert_matches!($($arg)*); }
if $crate::cfg!(debug_assertions) {
$crate::assert_matches::assert_matches!($($arg)*);
}
}
/// Returns whether the given expression matches any of the given patterns.
@ -331,7 +345,7 @@ macro_rules! matches {
$( $pattern )|+ $( if $guard )? => true,
_ => false
}
}
};
}
/// Unwraps a result or propagates its error.
@ -482,7 +496,9 @@ macro_rules! r#try {
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "write_macro")]
macro_rules! write {
($dst:expr, $($arg:tt)*) => ($dst.write_fmt($crate::format_args!($($arg)*)))
($dst:expr, $($arg:tt)*) => {
$dst.write_fmt($crate::format_args!($($arg)*))
};
}
/// Write formatted data into a buffer, with a newline appended.
@ -534,12 +550,12 @@ macro_rules! write {
#[cfg_attr(not(test), rustc_diagnostic_item = "writeln_macro")]
#[allow_internal_unstable(format_args_nl)]
macro_rules! writeln {
($dst:expr $(,)?) => (
($dst:expr $(,)?) => {
$crate::write!($dst, "\n")
);
($dst:expr, $($arg:tt)*) => (
};
($dst:expr, $($arg:tt)*) => {
$dst.write_fmt($crate::format_args_nl!($($arg)*))
);
};
}
/// Indicates unreachable code.
@ -683,8 +699,12 @@ macro_rules! unreachable {
#[cfg_attr(not(test), rustc_diagnostic_item = "unimplemented_macro")]
#[allow_internal_unstable(core_panic)]
macro_rules! unimplemented {
() => ($crate::panicking::panic("not implemented"));
($($arg:tt)+) => ($crate::panic!("not implemented: {}", $crate::format_args!($($arg)+)));
() => {
$crate::panicking::panic("not implemented")
};
($($arg:tt)+) => {
$crate::panic!("not implemented: {}", $crate::format_args!($($arg)+))
};
}
/// Indicates unfinished code.
@ -746,8 +766,12 @@ macro_rules! unimplemented {
#[cfg_attr(not(test), rustc_diagnostic_item = "todo_macro")]
#[allow_internal_unstable(core_panic)]
macro_rules! todo {
() => ($crate::panicking::panic("not yet implemented"));
($($arg:tt)+) => ($crate::panic!("not yet implemented: {}", $crate::format_args!($($arg)+)));
() => {
$crate::panicking::panic("not yet implemented")
};
($($arg:tt)+) => {
$crate::panic!("not yet implemented: {}", $crate::format_args!($($arg)+))
};
}
/// Definitions of built-in macros.

28
library/std/src/macros.rs
View File

@ -60,7 +60,9 @@ macro_rules! panic {
#[cfg_attr(not(test), rustc_diagnostic_item = "print_macro")]
#[allow_internal_unstable(print_internals)]
macro_rules! print {
($($arg:tt)*) => ($crate::io::_print($crate::format_args!($($arg)*)));
($($arg:tt)*) => {
$crate::io::_print($crate::format_args!($($arg)*))
};
}
/// Prints to the standard output, with a newline.
@ -94,10 +96,12 @@ macro_rules! print {
#[cfg_attr(not(test), rustc_diagnostic_item = "println_macro")]
#[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! println {
() => ($crate::print!("\n"));
($($arg:tt)*) => ({
$crate::io::_print($crate::format_args_nl!($($arg)*));
})
() => {
$crate::print!("\n")
};
($($arg:tt)*) => {
$crate::io::_print($crate::format_args_nl!($($arg)*))
};
}
/// Prints to the standard error.
@ -126,7 +130,9 @@ macro_rules! println {
#[cfg_attr(not(test), rustc_diagnostic_item = "eprint_macro")]
#[allow_internal_unstable(print_internals)]
macro_rules! eprint {
($($arg:tt)*) => ($crate::io::_eprint($crate::format_args!($($arg)*)));
($($arg:tt)*) => {
$crate::io::_eprint($crate::format_args!($($arg)*))
};
}
/// Prints to the standard error, with a newline.
@ -155,10 +161,12 @@ macro_rules! eprint {
#[cfg_attr(not(test), rustc_diagnostic_item = "eprintln_macro")]
#[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! eprintln {
() => ($crate::eprint!("\n"));
($($arg:tt)*) => ({
$crate::io::_eprint($crate::format_args_nl!($($arg)*));
})
() => {
$crate::eprint!("\n")
};
($($arg:tt)*) => {
$crate::io::_eprint($crate::format_args_nl!($($arg)*))
};
}
/// Prints and returns the value of a given expression for quick and dirty

2
src/test/pretty/dollar-crate.pp
View File

@ -9,5 +9,5 @@ extern crate std;
// pp-exact:dollar-crate.pp
fn main() {
{ ::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"], &[])); };
::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"], &[]));
}

2
src/test/ui/macros/trace-macro.stderr
View File

@ -5,5 +5,5 @@ LL | println!("Hello, World!");
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: expanding `println! { "Hello, World!" }`
= note: to `{ $crate :: io :: _print($crate :: format_args_nl! ("Hello, World!")) ; }`
= note: to `$crate :: io :: _print($crate :: format_args_nl! ("Hello, World!"))`

2
src/test/ui/parser/issues/issue-62894.stderr
View File

@ -45,7 +45,7 @@ LL | fn main() {}
|
::: $SRC_DIR/core/src/macros/mod.rs:LL:COL
|
LL | ($left:expr, $right:expr $(,)?) => ({
LL | ($left:expr, $right:expr $(,)?) => {
| ---------- while parsing argument for this `expr` macro fragment
error: aborting due to 4 previous errors

2
src/test/ui/pattern/usefulness/tuple-struct-nonexhaustive.stderr
View File

@ -12,7 +12,7 @@ LL | struct Foo(isize, isize);
= note: the matched value is of type `Foo`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
|
LL ~ Foo(2, b) => println!("{}", b)
LL ~ Foo(2, b) => println!("{}", b),
LL + Foo(_, _) => todo!()
|