nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-27 09:14:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #94868 - dtolnay:noblock, r=Dylan-DPC

Browse Source 
Format core and std macro rules, removing needless surrounding blocks

Many of the asserting and printing macros in `core` and `std` are written with prehistoric-looking formatting, like this:

335ffbfa54/library/std/src/macros.rs (L96-L101)

In modern Rust style this would conventionally be written as follows instead, always using braces and a trailing semicolon on the macro arms:

af53809c87/library/std/src/macros.rs (L98-L105)

Getting rid of the unneeded braces inside the expansion reduces extraneous indentation in macro-expanded code. For example:

```rust
println!("repro {}", true);
```

```rust
// before:

{
    ::std::io::_print(
        ::core::fmt::Arguments::new_v1(
            &["repro ", "\n"],
            &[::core::fmt::ArgumentV1::new_display(&true)],
        ),
    );
};
```

```rust
// after:

::std::io::_print(
    ::core::fmt::Arguments::new_v1(
        &["repro ", "\n"],
        &[::core::fmt::ArgumentV1::new_display(&true)],
    ),
);
```
This commit is contained in:
Dylan DPC 2022-03-16 03:34:32 +01:00 committed by GitHub
commit f986c7434a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 76 additions and 44 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")] #[cfg_attr(not(test), rustc_diagnostic_item = "assert_eq_macro")]
#[allow_internal_unstable(core_panic)] #[allow_internal_unstable(core_panic)]
macro_rules! assert_eq { macro_rules! assert_eq {
($left:expr, $right:expr $(,)?) => ({ ($left:expr, $right:expr $(,)?) => {
match (&$left, &$right) { match (&$left, &$right) {
(left_val, right_val) => { (left_val, right_val) => {
if !(*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) { match (&$left, &$right) {
(left_val, right_val) => { (left_val, right_val) => {
if !(*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`]). /// 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")] #[cfg_attr(not(test), rustc_diagnostic_item = "assert_ne_macro")]
#[allow_internal_unstable(core_panic)] #[allow_internal_unstable(core_panic)]
macro_rules! assert_ne { macro_rules! assert_ne {
($left:expr, $right:expr $(,)?) => ({ ($left:expr, $right:expr $(,)?) => {
match (&$left, &$right) { match (&$left, &$right) {
(left_val, right_val) => { (left_val, right_val) => {
if *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)) { match (&($left), &($right)) {
(left_val, right_val) => { (left_val, right_val) => {
if *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. /// Asserts that an expression matches any of the given patterns.
@ -142,7 +142,7 @@ macro_rules! assert_ne {
#[allow_internal_unstable(core_panic)] #[allow_internal_unstable(core_panic)]
#[rustc_macro_transparency = "semitransparent"] #[rustc_macro_transparency = "semitransparent"]
pub macro assert_matches { pub macro assert_matches {
($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => ({ ($left:expr, $(|)? $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => {
match $left { match $left {
$( $pattern )|+ $( if $guard )? => {} $( $pattern )|+ $( if $guard )? => {}
ref left_val => { 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 { match $left {
$( $pattern )|+ $( if $guard )? => {} $( $pattern )|+ $( if $guard )? => {}
ref left_val => { ref left_val => {
@ -165,7 +165,7 @@ pub macro assert_matches {
); );
} }
} }
}), },
} }
/// Asserts that a boolean expression is `true` at runtime. /// Asserts that a boolean expression is `true` at runtime.
@ -214,7 +214,11 @@ pub macro assert_matches {
#[rustc_diagnostic_item = "debug_assert_macro"] #[rustc_diagnostic_item = "debug_assert_macro"]
#[allow_internal_unstable(edition_panic)] #[allow_internal_unstable(edition_panic)]
macro_rules! debug_assert { 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. /// Asserts that two expressions are equal to each other.
@ -240,7 +244,11 @@ macro_rules! debug_assert {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_eq_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_eq_macro")]
macro_rules! debug_assert_eq { 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. /// 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")] #[stable(feature = "assert_ne", since = "1.13.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_ne_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "debug_assert_ne_macro")]
macro_rules! debug_assert_ne { 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. /// Asserts that an expression matches any of the given patterns.
@ -305,7 +317,9 @@ macro_rules! debug_assert_ne {
#[allow_internal_unstable(assert_matches)] #[allow_internal_unstable(assert_matches)]
#[rustc_macro_transparency = "semitransparent"] #[rustc_macro_transparency = "semitransparent"]
pub macro debug_assert_matches($($arg:tt)*) { 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. /// Returns whether the given expression matches any of the given patterns.
@ -331,7 +345,7 @@ macro_rules! matches {
$( $pattern )|+ $( if $guard )? => true, $( $pattern )|+ $( if $guard )? => true,
_ => false _ => false
} }
} };
} }
/// Unwraps a result or propagates its error. /// Unwraps a result or propagates its error.
@ -482,7 +496,9 @@ macro_rules! r#try {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "write_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "write_macro")]
macro_rules! write { 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. /// 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")] #[cfg_attr(not(test), rustc_diagnostic_item = "writeln_macro")]
#[allow_internal_unstable(format_args_nl)] #[allow_internal_unstable(format_args_nl)]
macro_rules! writeln { macro_rules! writeln {
($dst:expr $(,)?) => ( ($dst:expr $(,)?) => {
$crate::write!($dst, "\n") $crate::write!($dst, "\n")
); };
($dst:expr, $($arg:tt)*) => ( ($dst:expr, $($arg:tt)*) => {
$dst.write_fmt($crate::format_args_nl!($($arg)*)) $dst.write_fmt($crate::format_args_nl!($($arg)*))
); };
} }
/// Indicates unreachable code. /// Indicates unreachable code.
@ -683,8 +699,12 @@ macro_rules! unreachable {
#[cfg_attr(not(test), rustc_diagnostic_item = "unimplemented_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "unimplemented_macro")]
#[allow_internal_unstable(core_panic)] #[allow_internal_unstable(core_panic)]
macro_rules! unimplemented { 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. /// Indicates unfinished code.
@ -746,8 +766,12 @@ macro_rules! unimplemented {
#[cfg_attr(not(test), rustc_diagnostic_item = "todo_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "todo_macro")]
#[allow_internal_unstable(core_panic)] #[allow_internal_unstable(core_panic)]
macro_rules! todo { 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. /// 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")] #[cfg_attr(not(test), rustc_diagnostic_item = "print_macro")]
#[allow_internal_unstable(print_internals)] #[allow_internal_unstable(print_internals)]
macro_rules! print { 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. /// Prints to the standard output, with a newline.
@ -94,10 +96,12 @@ macro_rules! print {
#[cfg_attr(not(test), rustc_diagnostic_item = "println_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "println_macro")]
#[allow_internal_unstable(print_internals, format_args_nl)] #[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! println { macro_rules! println {
() => ($crate::print!("\n")); () => {
($($arg:tt)*) => ({ $crate::print!("\n")
$crate::io::_print($crate::format_args_nl!($($arg)*)); };
}) ($($arg:tt)*) => {
$crate::io::_print($crate::format_args_nl!($($arg)*))
};
} }
/// Prints to the standard error. /// Prints to the standard error.
@ -126,7 +130,9 @@ macro_rules! println {
#[cfg_attr(not(test), rustc_diagnostic_item = "eprint_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "eprint_macro")]
#[allow_internal_unstable(print_internals)] #[allow_internal_unstable(print_internals)]
macro_rules! eprint { 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. /// Prints to the standard error, with a newline.
@ -155,10 +161,12 @@ macro_rules! eprint {
#[cfg_attr(not(test), rustc_diagnostic_item = "eprintln_macro")] #[cfg_attr(not(test), rustc_diagnostic_item = "eprintln_macro")]
#[allow_internal_unstable(print_internals, format_args_nl)] #[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! eprintln { macro_rules! eprintln {
() => ($crate::eprint!("\n")); () => {
($($arg:tt)*) => ({ $crate::eprint!("\n")
$crate::io::_eprint($crate::format_args_nl!($($arg)*)); };
}) ($($arg:tt)*) => {
$crate::io::_eprint($crate::format_args_nl!($($arg)*))
};
} }
/// Prints and returns the value of a given expression for quick and dirty /// 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 // pp-exact:dollar-crate.pp
fn main() { fn main() {
{ ::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"], &[])); }; ::std::io::_print(::core::fmt::Arguments::new_v1(&["rust\n"], &[]));
} }

8
src/test/run-make-fulldeps/coverage-reports/expected_show_coverage.closure.txt
View File

@ -116,8 +116,8 @@
116| 1| 116| 1|
117| 1| let 117| 1| let
118| 1| _unused_closure 118| 1| _unused_closure
119| | = 119| 1| =
120| | | 120| 1| |
121| | mut countdown 121| | mut countdown
122| | | 122| | |
123| 0| { 123| 0| {
@ -173,7 +173,7 @@
169| | ; 169| | ;
170| | 170| |
171| 1| let short_used_not_covered_closure_line_break_no_block_embedded_branch = 171| 1| let short_used_not_covered_closure_line_break_no_block_embedded_branch =
172| | | _unused_arg: u8 | 172| 1| | _unused_arg: u8 |
173| 0| println!( 173| 0| println!(
174| 0| "not called: {}", 174| 0| "not called: {}",
175| 0| if is_true { "check" } else { "me" } 175| 0| if is_true { "check" } else { "me" }
@ -191,7 +191,7 @@
187| | ; 187| | ;
188| | 188| |
189| 1| let short_used_covered_closure_line_break_no_block_embedded_branch = 189| 1| let short_used_covered_closure_line_break_no_block_embedded_branch =
190| 1| | _unused_arg: u8 | 190| | | _unused_arg: u8 |
191| 1| println!( 191| 1| println!(
192| 1| "not called: {}", 192| 1| "not called: {}",
193| 1| if is_true { "check" } else { "me" } 193| 1| if is_true { "check" } else { "me" }

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

@ -5,5 +5,5 @@ LL | println!("Hello, World!");
| ^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^
| |
= note: expanding `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 ::: $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 | ---------- while parsing argument for this `expr` macro fragment
error: aborting due to 4 previous errors 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` = 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 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!() LL + Foo(_, _) => todo!()
| |