diff --git a/library/alloc/src/macros.rs b/library/alloc/src/macros.rs
index d93e279df7cfb..2c9f5a6833ecf 100644
--- a/library/alloc/src/macros.rs
+++ b/library/alloc/src/macros.rs
@@ -45,7 +45,7 @@ macro_rules! vec {
         $crate::vec::Vec::new()
     );
     ($elem:expr; $n:expr) => (
-        $crate::vec::from_elem($elem, $n)
+        $crate::vec::from_elem_global($elem, $n)
     );
     ($($x:expr),+ $(,)?) => (
         // Using `write_box_via_move` produces a dramatic improvement in stack usage for unoptimized
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index e2be7941cf94d..b9c28b217694f 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -3941,11 +3941,24 @@ fn find_first_duplicate<T: PartialEq>(v: &[T], chunk_size: usize) -> Option<usiz
 // Internal methods and functions
 ////////////////////////////////////////////////////////////////////////////////
 
+// This function is no longer used internally (`from_elem_global` is used instead).
+// It is only kept so as not to break a few crates who mistakenly used it at a
+// time when we didn't have the ability to gate internal methods used by public macros.
 #[doc(hidden)]
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_diagnostic_item = "vec_from_elem"]
+// NOTE: the real deprecation version is the same as the stabilization version.
+// I.e. it should never have been used even in version 1.0.
+#[deprecated(since = "CURRENT_RUSTC_VERSION", note = "use the `vec!` macro instead")]
 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
+    vec![elem; n]
+}
+
+#[doc(hidden)]
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "liballoc_internals", issue = "none")]
+#[rustc_diagnostic_item = "vec_from_elem"]
+pub fn from_elem_global<T: Clone>(elem: T, n: usize) -> Vec<T> {
     <T as SpecFromElem>::from_elem(elem, n, Global)
 }
 
diff --git a/tests/ui/array-slice-vec/vec-spec-extend-with-correct-drop.rs b/tests/ui/array-slice-vec/vec-spec-extend-with-correct-drop.rs
index 7affe9826f9b5..c814c328d836d 100644
--- a/tests/ui/array-slice-vec/vec-spec-extend-with-correct-drop.rs
+++ b/tests/ui/array-slice-vec/vec-spec-extend-with-correct-drop.rs
@@ -3,7 +3,6 @@
 
 use std::cell::Cell;
 use std::clone::TrivialClone;
-use std::vec::from_elem;
 
 #[derive(Clone)]
 struct DropCounter<'a>(&'a Cell<i32>);
@@ -44,16 +43,16 @@ fn main() {
     // TrivialClone
     let c = Cell::new(0);
 
-    let mut vec = from_elem(DropCounter(&c), 3);
+    let mut vec = vec![DropCounter(&c); 3];
     vec.clear();
 
     assert_eq!(c.get(), 3);
-    vec = from_elem(DropCounter(&c), 6);
+    vec = vec![DropCounter(&c); 6];
     vec.clear();
 
     assert_eq!(c.get(), 9);
 
-    vec = from_elem(DropCounter(&c), 0);
+    vec = vec![DropCounter(&c); 0];
     assert_eq!(c.get(), 10);
     vec.clear();
     assert_eq!(c.get(), 10);
@@ -62,21 +61,21 @@ fn main() {
     let clones = Cell::new(0);
     let drops = Cell::new(0);
 
-    let mut vec = from_elem(CloneCounter::new(&clones, &drops), 3);
+    let mut vec = vec![CloneCounter::new(&clones, &drops); 3];
     assert_eq!(clones.get(), 2);
     assert_eq!(drops.get(), 0);
     vec.clear();
     assert_eq!(clones.get(), 2);
     assert_eq!(drops.get(), 3);
 
-    vec = from_elem(CloneCounter::new(&clones, &drops), 6);
+    vec = vec![CloneCounter::new(&clones, &drops); 6];
     assert_eq!(clones.get(), 7);
     assert_eq!(drops.get(), 3);
     vec.clear();
     assert_eq!(clones.get(), 7);
     assert_eq!(drops.get(), 9);
 
-    vec = from_elem(CloneCounter::new(&clones, &drops), 0);
+    vec = vec![CloneCounter::new(&clones, &drops); 0];
     assert_eq!(clones.get(), 7);
     assert_eq!(drops.get(), 10);
     vec.clear();