3 files changed, 4 insertions, 1 deletions
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index f5980f4599e..e52a0216dd3 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -60,7 +60,7 @@ const MAX_REFCOUNT: usize = (isize::MAX) as usize;
 /// ## Thread Safety
 ///
 /// Unlike [`Rc<T>`], `Arc<T>` uses atomic operations for its reference
-/// counting  This means that it is thread-safe. The disadvantage is that
+/// counting. This means that it is thread-safe. The disadvantage is that
 /// atomic operations are more expensive than ordinary memory accesses. If you
 /// are not sharing reference-counted values between threads, consider using
 /// [`Rc<T>`] for lower overhead. [`Rc<T>`] is a safe default, because the
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 6399be98cd5..021395d0c82 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -96,6 +96,7 @@
 #![feature(dropck_eyepatch)]
 #![feature(exact_size_is_empty)]
 #![feature(fmt_internals)]
+#![feature(fn_must_use)]
 #![feature(from_ref)]
 #![feature(fundamental)]
 #![feature(lang_items)]
diff --git a/src/liballoc/str.rs b/src/liballoc/str.rs
index cac94edf649..0cbe65db53c 100644
--- a/src/liballoc/str.rs
+++ b/src/liballoc/str.rs
@@ -207,6 +207,7 @@ impl str {
     /// let s = "this is old";
     /// assert_eq!(s, s.replace("cookie monster", "little lamb"));
     /// ```
+    #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {
@@ -246,6 +247,7 @@ impl str {
     /// let s = "this is old";
     /// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
     /// ```
+    #[must_use]
     #[stable(feature = "str_replacen", since = "1.16.0")]
     pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String {
         // Hope to reduce the times of re-allocation