From a81d4b18ea7ee03733e983974400816684f78ebe Mon Sep 17 00:00:00 2001 From: John Kugelman Date: Sat, 30 Oct 2021 23:37:32 -0400 Subject: [PATCH] Add #[must_use] to remaining std functions (O-Z) --- library/std/src/os/unix/net/ancillary.rs | 6 ++++++ library/std/src/os/unix/net/listener.rs | 1 + library/std/src/os/unix/process.rs | 1 + library/std/src/panicking.rs | 3 +++ library/std/src/path.rs | 15 +++++++++++++++ library/std/src/process.rs | 13 +++++++++++++ library/std/src/sync/condvar.rs | 1 + library/std/src/sync/mpsc/mod.rs | 2 ++ library/std/src/sys_common/process.rs | 1 + library/std/src/thread/mod.rs | 5 +++++ library/std/src/time.rs | 7 +++++++ library/std/src/time/tests.rs | 4 ++-- 12 files changed, 57 insertions(+), 2 deletions(-) diff --git a/library/std/src/os/unix/net/ancillary.rs b/library/std/src/os/unix/net/ancillary.rs index 57bb61903c1..00f973b5e46 100644 --- a/library/std/src/os/unix/net/ancillary.rs +++ b/library/std/src/os/unix/net/ancillary.rs @@ -201,6 +201,7 @@ impl SocketCred { } /// Get the current PID. + #[must_use] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn get_pid(&self) -> libc::pid_t { self.0.pid @@ -213,6 +214,7 @@ impl SocketCred { } /// Get the current UID. + #[must_use] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn get_uid(&self) -> libc::uid_t { self.0.uid @@ -225,6 +227,7 @@ impl SocketCred { } /// Get the current GID. + #[must_use] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn get_gid(&self) -> libc::gid_t { self.0.gid @@ -330,6 +333,7 @@ impl<'a> AncillaryData<'a> { } /// This struct is used to iterate through the control messages. +#[must_use = "iterators are lazy and do nothing unless consumed"] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub struct Messages<'a> { buffer: &'a [u8], @@ -425,6 +429,7 @@ impl<'a> SocketAncillary<'a> { } /// Returns the capacity of the buffer. + #[must_use] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn capacity(&self) -> usize { self.buffer.len() @@ -471,6 +476,7 @@ impl<'a> SocketAncillary<'a> { /// Ok(()) /// } /// ``` + #[must_use] #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")] pub fn truncated(&self) -> bool { self.truncated diff --git a/library/std/src/os/unix/net/listener.rs b/library/std/src/os/unix/net/listener.rs index 97348afe7de..b23dd6062f6 100644 --- a/library/std/src/os/unix/net/listener.rs +++ b/library/std/src/os/unix/net/listener.rs @@ -365,6 +365,7 @@ impl<'a> IntoIterator for &'a UnixListener { /// } /// ``` #[derive(Debug)] +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "unix_socket", since = "1.10.0")] pub struct Incoming<'a> { listener: &'a UnixListener, diff --git a/library/std/src/os/unix/process.rs b/library/std/src/os/unix/process.rs index 9b94615d247..286a7c3b386 100644 --- a/library/std/src/os/unix/process.rs +++ b/library/std/src/os/unix/process.rs @@ -436,6 +436,7 @@ impl From for OwnedFd { } /// Returns the OS-assigned process identifier associated with this process's parent. +#[must_use] #[stable(feature = "unix_ppid", since = "1.27.0")] pub fn parent_id() -> u32 { crate::sys::os::getppid() diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs index 437fcbb3176..6fc6b8daec0 100644 --- a/library/std/src/panicking.rs +++ b/library/std/src/panicking.rs @@ -160,6 +160,7 @@ pub fn set_hook(hook: Box) + 'static + Sync + Send>) { /// /// panic!("Normal panic"); /// ``` +#[must_use] #[stable(feature = "panic_hooks", since = "1.10.0")] pub fn take_hook() -> Box) + 'static + Sync + Send> { if thread::panicking() { @@ -284,11 +285,13 @@ pub mod panic_count { } // Disregards ALWAYS_ABORT_FLAG + #[must_use] pub fn get_count() -> usize { LOCAL_PANIC_COUNT.with(|c| c.get()) } // Disregards ALWAYS_ABORT_FLAG + #[must_use] #[inline] pub fn count_is_zero() -> bool { if GLOBAL_PANIC_COUNT.load(Ordering::Relaxed) & !ALWAYS_ABORT_FLAG == 0 { diff --git a/library/std/src/path.rs b/library/std/src/path.rs index 8f00d2260e4..4672fea1fdd 100644 --- a/library/std/src/path.rs +++ b/library/std/src/path.rs @@ -422,6 +422,7 @@ impl<'a> PrefixComponent<'a> { /// See [`Prefix`]'s documentation for more information on the different /// kinds of prefixes. #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] #[inline] pub fn kind(&self) -> Prefix<'a> { self.parsed @@ -583,6 +584,7 @@ impl AsRef for Component<'_> { /// /// [`components`]: Path::components #[derive(Clone)] +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] pub struct Components<'a> { // The path left to parse components from @@ -609,6 +611,7 @@ pub struct Components<'a> { /// /// [`iter`]: Path::iter #[derive(Clone)] +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "rust1", since = "1.0.0")] pub struct Iter<'a> { inner: Components<'a>, @@ -1051,6 +1054,7 @@ fn compare_components(mut left: Components<'_>, mut right: Components<'_>) -> cm /// /// [`ancestors`]: Path::ancestors #[derive(Copy, Clone, Debug)] +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "path_ancestors", since = "1.28.0")] pub struct Ancestors<'a> { next: Option<&'a Path>, @@ -1459,6 +1463,7 @@ impl PathBuf { /// /// [`capacity`]: OsString::capacity #[stable(feature = "path_buf_capacity", since = "1.44.0")] + #[must_use] #[inline] pub fn capacity(&self) -> usize { self.inner.capacity() @@ -2103,6 +2108,7 @@ impl Path { /// assert_eq!(grand_parent.parent(), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn parent(&self) -> Option<&Path> { let mut comps = self.components(); let comp = comps.next_back(); @@ -2169,6 +2175,7 @@ impl Path { /// assert_eq!(None, Path::new("/").file_name()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn file_name(&self) -> Option<&OsStr> { self.components().next_back().and_then(|p| match p { Component::Normal(p) => Some(p), @@ -2241,6 +2248,7 @@ impl Path { /// assert!(!Path::new("/etc/foo.rs").starts_with("/etc/foo")); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn starts_with>(&self, base: P) -> bool { self._starts_with(base.as_ref()) } @@ -2268,6 +2276,7 @@ impl Path { /// assert!(!path.ends_with("conf")); // use .extension() instead /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn ends_with>(&self, child: P) -> bool { self._ends_with(child.as_ref()) } @@ -2303,6 +2312,7 @@ impl Path { /// [`Path::file_prefix`]: Path::file_prefix /// #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn file_stem(&self) -> Option<&OsStr> { self.file_name().map(rsplit_file_at_dot).and_then(|(before, after)| before.or(after)) } @@ -2336,6 +2346,7 @@ impl Path { /// [`Path::file_stem`]: Path::file_stem /// #[unstable(feature = "path_file_prefix", issue = "86319")] + #[must_use] pub fn file_prefix(&self) -> Option<&OsStr> { self.file_name().map(split_file_at_dot).and_then(|(before, _after)| Some(before)) } @@ -2360,6 +2371,7 @@ impl Path { /// assert_eq!("gz", Path::new("foo.tar.gz").extension().unwrap()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn extension(&self) -> Option<&OsStr> { self.file_name().map(rsplit_file_at_dot).and_then(|(before, after)| before.and(after)) } @@ -2403,6 +2415,7 @@ impl Path { /// assert_eq!(path.with_file_name("var"), PathBuf::from("/var")); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn with_file_name>(&self, file_name: S) -> PathBuf { self._with_file_name(file_name.as_ref()) } @@ -2660,6 +2673,7 @@ impl Path { /// This is a convenience function that coerces errors to false. If you want to /// check errors, call [`fs::metadata`]. #[stable(feature = "path_ext", since = "1.5.0")] + #[must_use] #[inline] pub fn exists(&self) -> bool { fs::metadata(self).is_ok() @@ -2781,6 +2795,7 @@ impl Path { /// Converts a [`Box`](Box) into a [`PathBuf`] without copying or /// allocating. #[stable(feature = "into_boxed_path", since = "1.20.0")] + #[must_use = "`self` will be dropped if the result is not used"] pub fn into_path_buf(self: Box) -> PathBuf { let rw = Box::into_raw(self) as *mut OsStr; let inner = unsafe { Box::from_raw(rw) }; diff --git a/library/std/src/process.rs b/library/std/src/process.rs index 4bd06475e27..9cc7fc2f035 100644 --- a/library/std/src/process.rs +++ b/library/std/src/process.rs @@ -948,6 +948,7 @@ impl Command { /// let cmd = Command::new("echo"); /// assert_eq!(cmd.get_program(), "echo"); /// ``` + #[must_use] #[stable(feature = "command_access", since = "1.57.0")] pub fn get_program(&self) -> &OsStr { self.inner.get_program() @@ -1021,6 +1022,7 @@ impl Command { /// cmd.current_dir("/bin"); /// assert_eq!(cmd.get_current_dir(), Some(Path::new("/bin"))); /// ``` + #[must_use] #[stable(feature = "command_access", since = "1.57.0")] pub fn get_current_dir(&self) -> Option<&Path> { self.inner.get_current_dir() @@ -1053,6 +1055,7 @@ impl AsInnerMut for Command { /// /// This struct is created by [`Command::get_args`]. See its documentation for /// more. +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "command_access", since = "1.57.0")] #[derive(Debug)] pub struct CommandArgs<'a> { @@ -1183,6 +1186,7 @@ impl Stdio { /// its entire stdin before writing more than a pipe buffer's worth of output. /// The size of a pipe buffer varies on different targets. /// + #[must_use] #[stable(feature = "process", since = "1.0.0")] pub fn piped() -> Stdio { Stdio(imp::Stdio::MakePipe) @@ -1222,6 +1226,7 @@ impl Stdio { /// print!("You piped in the reverse of: "); /// io::stdout().write_all(&output.stdout).unwrap(); /// ``` + #[must_use] #[stable(feature = "process", since = "1.0.0")] pub fn inherit() -> Stdio { Stdio(imp::Stdio::Inherit) @@ -1261,6 +1266,7 @@ impl Stdio { /// assert_eq!(String::from_utf8_lossy(&output.stdout), ""); /// // Ignores any piped-in input /// ``` + #[must_use] #[stable(feature = "process", since = "1.0.0")] pub fn null() -> Stdio { Stdio(imp::Stdio::Null) @@ -1462,6 +1468,7 @@ impl ExitStatus { /// println!("failed to create 'projects/' directory: {}", status); /// } /// ``` + #[must_use] #[stable(feature = "process", since = "1.0.0")] pub fn success(&self) -> bool { self.0.exit_ok().is_ok() @@ -1493,6 +1500,7 @@ impl ExitStatus { /// None => println!("Process terminated by signal") /// } /// ``` + #[must_use] #[stable(feature = "process", since = "1.0.0")] pub fn code(&self) -> Option { self.0.code() @@ -1580,6 +1588,7 @@ impl ExitStatusError { /// assert_eq!(bad.code(), Some(1)); /// # } // #[cfg(unix)] /// ``` + #[must_use] pub fn code(&self) -> Option { self.code_nonzero().map(Into::into) } @@ -1605,11 +1614,13 @@ impl ExitStatusError { /// assert_eq!(bad.code_nonzero().unwrap(), NonZeroI32::try_from(1).unwrap()); /// # } // cfg!(unix) /// ``` + #[must_use] pub fn code_nonzero(&self) -> Option { self.0.code() } /// Converts an `ExitStatusError` (back) to an `ExitStatus`. + #[must_use] pub fn into_status(&self) -> ExitStatus { ExitStatus(self.0.into()) } @@ -1718,6 +1729,7 @@ impl Child { /// println!("ls command didn't start"); /// } /// ``` + #[must_use] #[stable(feature = "process_id", since = "1.3.0")] pub fn id(&self) -> u32 { self.handle.id() @@ -1988,6 +2000,7 @@ pub fn abort() -> ! { /// ``` /// /// +#[must_use] #[stable(feature = "getpid", since = "1.26.0")] pub fn id() -> u32 { crate::sys::os::getpid() diff --git a/library/std/src/sync/condvar.rs b/library/std/src/sync/condvar.rs index d8aca9651b8..b41918ec1cf 100644 --- a/library/std/src/sync/condvar.rs +++ b/library/std/src/sync/condvar.rs @@ -61,6 +61,7 @@ impl WaitTimeoutResult { /// } /// } /// ``` + #[must_use] #[stable(feature = "wait_timeout", since = "1.5.0")] pub fn timed_out(&self) -> bool { self.0 diff --git a/library/std/src/sync/mpsc/mod.rs b/library/std/src/sync/mpsc/mod.rs index b4f4456537b..2cf678ef69b 100644 --- a/library/std/src/sync/mpsc/mod.rs +++ b/library/std/src/sync/mpsc/mod.rs @@ -707,6 +707,7 @@ impl UnsafeFlavor for Receiver { /// // Let's see what that answer was /// println!("{:?}", receiver.recv().unwrap()); /// ``` +#[must_use] #[stable(feature = "rust1", since = "1.0.0")] pub fn channel() -> (Sender, Receiver) { let a = Arc::new(oneshot::Packet::new()); @@ -755,6 +756,7 @@ pub fn channel() -> (Sender, Receiver) { /// assert_eq!(receiver.recv().unwrap(), 1); /// assert_eq!(receiver.recv().unwrap(), 2); /// ``` +#[must_use] #[stable(feature = "rust1", since = "1.0.0")] pub fn sync_channel(bound: usize) -> (SyncSender, Receiver) { let a = Arc::new(sync::Packet::new(bound)); diff --git a/library/std/src/sys_common/process.rs b/library/std/src/sys_common/process.rs index 3d71219756a..2cd1e29f6c4 100644 --- a/library/std/src/sys_common/process.rs +++ b/library/std/src/sys_common/process.rs @@ -106,6 +106,7 @@ impl CommandEnv { /// This struct is created by /// [`Command::get_envs`][crate::process::Command::get_envs]. See its /// documentation for more. +#[must_use = "iterators are lazy and do nothing unless consumed"] #[stable(feature = "command_access", since = "1.57.0")] #[derive(Debug)] pub struct CommandEnvs<'a> { diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs index 1a5cf5ab822..ac71c9664a6 100644 --- a/library/std/src/thread/mod.rs +++ b/library/std/src/thread/mod.rs @@ -649,6 +649,7 @@ where /// /// handler.join().unwrap(); /// ``` +#[must_use] #[stable(feature = "rust1", since = "1.0.0")] pub fn current() -> Thread { thread_info::current_thread().expect( @@ -737,6 +738,7 @@ pub fn yield_now() { /// /// [Mutex]: crate::sync::Mutex #[inline] +#[must_use] #[stable(feature = "rust1", since = "1.0.0")] pub fn panicking() -> bool { panicking::panicking() @@ -1131,6 +1133,7 @@ impl Thread { /// assert!(thread::current().id() != other_thread_id); /// ``` #[stable(feature = "thread_id", since = "1.19.0")] + #[must_use] pub fn id(&self) -> ThreadId { self.inner.id } @@ -1173,6 +1176,7 @@ impl Thread { /// /// [naming-threads]: ./index.html#naming-threads #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn name(&self) -> Option<&str> { self.cname().map(|s| unsafe { str::from_utf8_unchecked(s.to_bytes()) }) } @@ -1360,6 +1364,7 @@ impl JoinHandle { /// println!("thread id: {:?}", thread.id()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] pub fn thread(&self) -> &Thread { &self.0.thread } diff --git a/library/std/src/time.rs b/library/std/src/time.rs index 3e27e3a4297..a5e3bd0c290 100644 --- a/library/std/src/time.rs +++ b/library/std/src/time.rs @@ -239,6 +239,7 @@ impl Instant { /// /// let now = Instant::now(); /// ``` + #[must_use] #[stable(feature = "time2", since = "1.8.0")] pub fn now() -> Instant { let os_now = time::Instant::now(); @@ -306,6 +307,7 @@ impl Instant { /// let new_now = Instant::now(); /// println!("{:?}", new_now.duration_since(now)); /// ``` + #[must_use] #[stable(feature = "time2", since = "1.8.0")] pub fn duration_since(&self, earlier: Instant) -> Duration { self.0.checked_sub_instant(&earlier.0).expect("supplied instant is later than self") @@ -326,6 +328,7 @@ impl Instant { /// println!("{:?}", new_now.checked_duration_since(now)); /// println!("{:?}", now.checked_duration_since(new_now)); // None /// ``` + #[must_use] #[stable(feature = "checked_duration_since", since = "1.39.0")] pub fn checked_duration_since(&self, earlier: Instant) -> Option { self.0.checked_sub_instant(&earlier.0) @@ -346,6 +349,7 @@ impl Instant { /// println!("{:?}", new_now.saturating_duration_since(now)); /// println!("{:?}", now.saturating_duration_since(new_now)); // 0ns /// ``` + #[must_use] #[stable(feature = "checked_duration_since", since = "1.39.0")] pub fn saturating_duration_since(&self, earlier: Instant) -> Duration { self.checked_duration_since(earlier).unwrap_or_default() @@ -370,6 +374,7 @@ impl Instant { /// sleep(three_secs); /// assert!(instant.elapsed() >= three_secs); /// ``` + #[must_use] #[stable(feature = "time2", since = "1.8.0")] pub fn elapsed(&self) -> Duration { Instant::now() - *self @@ -476,6 +481,7 @@ impl SystemTime { /// /// let sys_time = SystemTime::now(); /// ``` + #[must_use] #[stable(feature = "time2", since = "1.8.0")] pub fn now() -> SystemTime { SystemTime(time::SystemTime::now()) @@ -644,6 +650,7 @@ impl SystemTimeError { /// Err(e) => println!("SystemTimeError difference: {:?}", e.duration()), /// } /// ``` + #[must_use] #[stable(feature = "time2", since = "1.8.0")] pub fn duration(&self) -> Duration { self.0 diff --git a/library/std/src/time/tests.rs b/library/std/src/time/tests.rs index dc44c9346b6..7279925a6d0 100644 --- a/library/std/src/time/tests.rs +++ b/library/std/src/time/tests.rs @@ -48,7 +48,7 @@ fn instant_monotonic_concurrent() -> crate::thread::Result<()> { #[test] fn instant_elapsed() { let a = Instant::now(); - a.elapsed(); + let _ = a.elapsed(); } #[test] @@ -93,7 +93,7 @@ fn instant_math_is_associative() { #[should_panic] fn instant_duration_since_panic() { let a = Instant::now(); - (a - Duration::SECOND).duration_since(a); + let _ = (a - Duration::SECOND).duration_since(a); } #[test]