mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mark format! with must_use hint

Browse Source
This commit is contained in:
lukas 2024-07-04 16:47:20 +02:00
parent 28cc0b643d
commit 3e9c9a05a8
22 changed files with 115 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
library/alloc/src/collections/btree/map/tests.rs
View File

@ -1796,18 +1796,18 @@ fn map<K>(mut map: BTreeMap<K, ()>) {
}
fn map_debug<K: Debug>(mut map: BTreeMap<K, ()>) {
format!("{map:?}");
format!("{:?}", map.iter());
format!("{:?}", map.iter_mut());
format!("{:?}", map.keys());
format!("{:?}", map.values());
format!("{:?}", map.values_mut());
let _ = format!("{map:?}");
let _ = format!("{:?}", map.iter());
let _ = format!("{:?}", map.iter_mut());
let _ = format!("{:?}", map.keys());
let _ = format!("{:?}", map.values());
let _ = format!("{:?}", map.values_mut());
if true {
format!("{:?}", map.into_iter());
let _ = format!("{:?}", map.into_iter());
} else if true {
format!("{:?}", map.into_keys());
let _ = format!("{:?}", map.into_keys());
} else {
format!("{:?}", map.into_values());
let _ = format!("{:?}", map.into_values());
}
}

6
library/alloc/src/collections/btree/set/tests.rs
View File

@ -705,9 +705,9 @@ fn set<K>(mut set: BTreeSet<K>) {
}
fn set_debug<K: Debug>(set: BTreeSet<K>) {
format!("{set:?}");
format!("{:?}", set.iter());
format!("{:?}", set.into_iter());
let _ = format!("{set:?}");
let _ = format!("{:?}", set.iter());
let _ = format!("{:?}", set.into_iter());
}
fn set_clone<K: Clone>(mut set: BTreeSet<K>) {

4
library/alloc/src/fmt.rs
View File

@ -12,6 +12,7 @@
//! Some examples of the [`format!`] extension are:
//!
//! ```
//! # #![allow(unused_must_use)]
//! format!("Hello"); // => "Hello"
//! format!("Hello, {}!", "world"); // => "Hello, world!"
//! format!("The number is {}", 1); // => "The number is 1"
@ -50,6 +51,7 @@
//! the iterator advances. This leads to behavior like this:
//!
//! ```
//! # #![allow(unused_must_use)]
//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
//! ```
//!
@ -77,6 +79,7 @@
//! For example, the following [`format!`] expressions all use named arguments:
//!
//! ```
//! # #![allow(unused_must_use)]
//! format!("{argument}", argument = "test"); // => "test"
//! format!("{name} {}", 1, name = 2); // => "2 1"
//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b"
@ -86,6 +89,7 @@
//! reference a variable with that name in the current scope.
//!
//! ```
//! # #![allow(unused_must_use)]
//! let argument = 2 + 2;
//! format!("{argument}"); // => "4"
//!

1
library/alloc/src/lib.rs
View File

@ -256,6 +256,7 @@ mod boxed {
#[unstable(feature = "liballoc_internals", issue = "none", reason = "implementation detail")]
pub mod __export {
pub use core::format_args;
pub use core::hint::must_use;
}
#[cfg(test)]

8
library/alloc/src/macros.rs
View File

@ -111,6 +111,7 @@ macro_rules! vec {
/// # Examples
///
/// ```
/// # #![allow(unused_must_use)]
/// format!("test"); // => "test"
/// format!("hello {}", "world!"); // => "hello world!"
/// format!("x = {}, y = {val}", 10, val = 30); // => "x = 10, y = 30"
@ -119,10 +120,13 @@ macro_rules! vec {
/// ```
#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
#[allow_internal_unstable(hint_must_use, liballoc_internals)]
#[cfg_attr(not(test), rustc_diagnostic_item = "format_macro")]
macro_rules! format {
($($arg:tt)*) => {{
($($arg:tt)*) => {
$crate::__export::must_use({
let res = $crate::fmt::format($crate::__export::format_args!($($arg)*));
res
}}
})
}
}

10
library/alloc/tests/fmt.rs
View File

@ -217,19 +217,19 @@ fn test_format_macro_interface() {
// make sure that format! doesn't move out of local variables
let a = Box::new(3);
format!("{a}");
format!("{a}");
let _ = format!("{a}");
let _ = format!("{a}");
// make sure that format! doesn't cause spurious unused-unsafe warnings when
// it's inside of an outer unsafe block
unsafe {
let a: isize = ::std::mem::transmute(3_usize);
format!("{a}");
let _ = format!("{a}");
}
// test that trailing commas are acceptable
format!("{}", "test",);
format!("{foo}", foo = "test",);
let _ = format!("{}", "test",);
let _ = format!("{foo}", foo = "test",);
}
// Basic test to make sure that we can invoke the `write!` macro with an

6
library/core/tests/fmt/builders.rs
View File

@ -441,7 +441,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
format!("{Foo:?}");
let _ = format!("{Foo:?}");
}
#[test]
@ -455,7 +455,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
format!("{Foo:?}");
let _ = format!("{Foo:?}");
}
#[test]
@ -469,7 +469,7 @@ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
format!("{Foo:?}");
let _ = format!("{Foo:?}");
}
}

6
src/bootstrap/src/core/build_steps/llvm.rs
View File

@ -755,7 +755,7 @@ fn configure_cmake(
}
if builder.config.llvm_clang_cl.is_some() {
cflags.push(&format!(" --target={target}"));
cflags.push(format!(" --target={target}"));
}
cfg.define("CMAKE_C_FLAGS", cflags);
let mut cxxflags: OsString = builder
@ -774,7 +774,7 @@ fn configure_cmake(
cxxflags.push(s);
}
if builder.config.llvm_clang_cl.is_some() {
cxxflags.push(&format!(" --target={target}"));
cxxflags.push(format!(" --target={target}"));
}
cfg.define("CMAKE_CXX_FLAGS", cxxflags);
if let Some(ar) = builder.ar(target) {
@ -915,7 +915,7 @@ fn run(self, builder: &Builder<'_>) -> PathBuf {
// Find clang's runtime library directory and push that as a search path to the
// cmake linker flags.
let clang_rt_dir = get_clang_cl_resource_dir(clang_cl_path);
ldflags.push_all(&format!("/libpath:{}", clang_rt_dir.display()));
ldflags.push_all(format!("/libpath:{}", clang_rt_dir.display()));
}
}

2
src/bootstrap/src/core/builder.rs
View File

@ -2527,7 +2527,7 @@ fn configure_linker(&mut self, builder: &Builder<'_>) -> &mut Cargo {
if let Some(target_linker) = builder.linker(target) {
let target = crate::envify(&target.triple);
self.command.env(&format!("CARGO_TARGET_{target}_LINKER"), target_linker);
self.command.env(format!("CARGO_TARGET_{target}_LINKER"), target_linker);
}
// We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not
// `linker_args` here.

2
src/tools/clippy/tests/ui/or_fun_call.fixed
View File

@ -98,7 +98,7 @@ fn or_fun_call() {
let opt = Some(1);
let hello = "Hello";
let _ = opt.ok_or(format!("{} world.", hello));
let _ = opt.ok_or_else(|| format!("{} world.", hello));
// index
let map = HashMap::<u64, u64>::new();

8
src/tools/clippy/tests/ui/or_fun_call.stderr
View File

@ -100,6 +100,12 @@ error: use of `unwrap_or` to construct default value
LL | let _ = stringy.unwrap_or(String::new());
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
error: use of `ok_or` followed by a function call
--> tests/ui/or_fun_call.rs:101:17
|
LL | let _ = opt.ok_or(format!("{} world.", hello));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
error: use of `unwrap_or` followed by a function call
--> tests/ui/or_fun_call.rs:105:21
|
@ -190,5 +196,5 @@ error: use of `unwrap_or_else` to construct default value
LL | let _ = stringy.unwrap_or_else(String::new);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
error: aborting due to 31 previous errors
error: aborting due to 32 previous errors

4
src/tools/miri/tests/pass/intptrcast.rs
View File

@ -35,7 +35,7 @@ fn cast_dangling() {
fn format() {
// Pointer string formatting! We can't check the output as it changes when libstd changes,
// but we can make sure Miri does not error.
format!("{:?}", &mut 13 as *mut _);
let _ = format!("{:?}", &mut 13 as *mut _);
}
fn transmute() {
@ -52,7 +52,7 @@ fn ptr_bitops1() {
let one = bytes.as_ptr().wrapping_offset(1);
let three = bytes.as_ptr().wrapping_offset(3);
let res = (one as usize) | (three as usize);
format!("{}", res);
let _ = format!("{}", res);
}
fn ptr_bitops2() {

2
src/tools/miri/tests/pass/packed_struct.rs
View File

@ -138,7 +138,7 @@ struct P {
assert_eq!(x.partial_cmp(&y).unwrap(), x.cmp(&y));
x.hash(&mut DefaultHasher::new());
P::default();
format!("{:?}", x);
let _ = format!("{:?}", x);
}
fn main() {

4
src/tools/miri/tests/pass/shims/fs.rs
View File

@ -202,7 +202,7 @@ fn test_errors() {
// Opening a non-existing file should fail with a "not found" error.
assert_eq!(ErrorKind::NotFound, File::open(&path).unwrap_err().kind());
// Make sure we can also format this.
format!("{0}: {0:?}", File::open(&path).unwrap_err());
let _ = format!("{0}: {0:?}", File::open(&path).unwrap_err());
// Removing a non-existing file should fail with a "not found" error.
assert_eq!(ErrorKind::NotFound, remove_file(&path).unwrap_err().kind());
// Reading the metadata of a non-existing file should fail with a "not found" error.
@ -301,5 +301,5 @@ fn test_from_raw_os_error() {
let error = Error::from_raw_os_error(code);
assert!(matches!(error.kind(), ErrorKind::Uncategorized));
// Make sure we can also format this.
format!("{error:?}");
let _ = format!("{error:?}");
}

2
src/tools/miri/tests/pass/shims/io.rs
View File

@ -15,5 +15,5 @@ fn main() {
panic!("unsupported OS")
};
let err = io::Error::from_raw_os_error(raw_os_error);
format!("{err}: {err:?}");
let _ = format!("{err}: {err:?}");
}

4
src/tools/miri/tests/pass/vecdeque.rs
View File

@ -31,8 +31,8 @@ fn main() {
}
// Regression test for Debug impl's
format!("{:?} {:?}", dst, dst.iter());
format!("{:?}", VecDeque::<u32>::new().iter());
let _ = format!("{:?} {:?}", dst, dst.iter());
let _ = format!("{:?}", VecDeque::<u32>::new().iter());
for a in dst {
assert_eq!(*a, 2);

5
tests/pretty/issue-4264.pp
View File

@ -29,7 +29,8 @@ fn bar() ({
({
((::alloc::__export::must_use as
fn(String) -> String {must_use::<String>})(({
let res =
((::alloc::fmt::format as
for<'a> fn(Arguments<'a>) -> String {format})(((format_arguments::new_const
@ -38,7 +39,7 @@ fn bar() ({
as &str)] as [&str; 1]) as &[&str; 1])) as Arguments<'_>))
as String);
(res as String)
} as String);
} as String)) as String);
} as ())
type Foo = [i32; (3 as usize)];
struct Bar {

2
tests/ui/deriving/deriving-in-fn.rs
View File

@ -9,5 +9,5 @@ struct Foo {
}
let f = Foo { foo: 10 };
format!("{:?}", f);
let _ = format!("{:?}", f);
}

14
tests/ui/fmt/struct-field-as-captured-argument.fixed
View File

@ -8,11 +8,11 @@ struct Foo {
fn main() {
let foo = Foo { field: 0 };
let bar = 3;
format!("{0}", foo.field); //~ ERROR invalid format string: field access isn't supported
format!("{1} {} {bar}", "aa", foo.field); //~ ERROR invalid format string: field access isn't supported
format!("{2} {} {1} {bar}", "aa", "bb", foo.field); //~ ERROR invalid format string: field access isn't supported
format!("{1} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{1:?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{0}", foo.field); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{1} {} {bar}", "aa", foo.field); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{2} {} {1} {bar}", "aa", "bb", foo.field); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{1} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{1:?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3); //~ ERROR invalid format string: field access isn't supported
}

14
tests/ui/fmt/struct-field-as-captured-argument.rs
View File

@ -8,11 +8,11 @@ struct Foo {
fn main() {
let foo = Foo { field: 0 };
let bar = 3;
format!("{foo.field}"); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field} {} {bar}", "aa"); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field} {} {1} {bar}", "aa", "bb"); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field:?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field:#?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
format!("{foo.field:.3} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field}"); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field} {} {bar}", "aa"); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field} {} {1} {bar}", "aa", "bb"); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field:?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field:#?} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
let _ = format!("{foo.field:.3} {} {baz}", "aa", baz = 3); //~ ERROR invalid format string: field access isn't supported
}

42
tests/ui/fmt/struct-field-as-captured-argument.stderr
View File

@ -1,78 +1,78 @@
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:11:15
--> $DIR/struct-field-as-captured-argument.rs:11:23
|
LL | format!("{foo.field}");
LL | let _ = format!("{foo.field}");
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{0}", foo.field);
LL | let _ = format!("{0}", foo.field);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:12:15
--> $DIR/struct-field-as-captured-argument.rs:12:23
|
LL | format!("{foo.field} {} {bar}", "aa");
LL | let _ = format!("{foo.field} {} {bar}", "aa");
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{1} {} {bar}", "aa", foo.field);
LL | let _ = format!("{1} {} {bar}", "aa", foo.field);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:13:15
--> $DIR/struct-field-as-captured-argument.rs:13:23
|
LL | format!("{foo.field} {} {1} {bar}", "aa", "bb");
LL | let _ = format!("{foo.field} {} {1} {bar}", "aa", "bb");
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{2} {} {1} {bar}", "aa", "bb", foo.field);
LL | let _ = format!("{2} {} {1} {bar}", "aa", "bb", foo.field);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:14:15
--> $DIR/struct-field-as-captured-argument.rs:14:23
|
LL | format!("{foo.field} {} {baz}", "aa", baz = 3);
LL | let _ = format!("{foo.field} {} {baz}", "aa", baz = 3);
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{1} {} {baz}", "aa", foo.field, baz = 3);
LL | let _ = format!("{1} {} {baz}", "aa", foo.field, baz = 3);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:15:15
--> $DIR/struct-field-as-captured-argument.rs:15:23
|
LL | format!("{foo.field:?} {} {baz}", "aa", baz = 3);
LL | let _ = format!("{foo.field:?} {} {baz}", "aa", baz = 3);
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{1:?} {} {baz}", "aa", foo.field, baz = 3);
LL | let _ = format!("{1:?} {} {baz}", "aa", foo.field, baz = 3);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:16:15
--> $DIR/struct-field-as-captured-argument.rs:16:23
|
LL | format!("{foo.field:#?} {} {baz}", "aa", baz = 3);
LL | let _ = format!("{foo.field:#?} {} {baz}", "aa", baz = 3);
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3);
LL | let _ = format!("{1:#?} {} {baz}", "aa", foo.field, baz = 3);
| ~ +++++++++++
error: invalid format string: field access isn't supported
--> $DIR/struct-field-as-captured-argument.rs:17:15
--> $DIR/struct-field-as-captured-argument.rs:17:23
|
LL | format!("{foo.field:.3} {} {baz}", "aa", baz = 3);
LL | let _ = format!("{foo.field:.3} {} {baz}", "aa", baz = 3);
| ^^^^^^^^^ not supported in format string
|
help: consider using a positional formatting argument instead
|
LL | format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3);
LL | let _ = format!("{1:.3} {} {baz}", "aa", foo.field, baz = 3);
| ~ +++++++++++
error: aborting due to 7 previous errors

2
tests/ui/issues/issue-20676.rs
View File

@ -8,5 +8,5 @@
fn main() {
let a: &dyn fmt::Debug = &1;
format!("{:?}", a);
let _ = format!("{:?}", a);
}