Auto merge of #150206 - Kivooeo:rollup-ddh45d8, r=Kivooeo

Rollup of 7 pull requests

Successful merges:

 - #147552 ([Debugger Visualizers] Optimize lookup behavior)
 - #149437 (Fix trailing newline in JUnit formatter)
 - #149812 (Add const default for OnceCell and OnceLock)
 - #150035 (fix docustring on fetch_or)
 - #150160 (Fix ICE (#149980) for invalid EII in statement position)
 - #150191 (change non-canonical clone impl to {*self}, fix some doc comments)
 - #150203 (Drop the From derive macro from the v1 prelude)

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_builtin_macros/src/eii.rs

@@ -60,12 +60,18 @@ fn eii_(
 ) -> Vec<Annotatable> {
     let eii_attr_span = ecx.with_def_site_ctxt(eii_attr_span);
 
-    let (item, stmt) = if let Annotatable::Item(item) = item {
-        (item, false)
+    let (item, wrap_item): (_, &dyn Fn(_) -> _) = if let Annotatable::Item(item) = item {
+        (item, &Annotatable::Item)
     } else if let Annotatable::Stmt(ref stmt) = item
         && let StmtKind::Item(ref item) = stmt.kind
     {
-        (item.clone(), true)
+        (item.clone(), &|item| {
+            Annotatable::Stmt(Box::new(Stmt {
+                id: DUMMY_NODE_ID,
+                kind: StmtKind::Item(item),
+                span: eii_attr_span,
+            }))
+        })
     } else {
         ecx.dcx().emit_err(EiiSharedMacroExpectedFunction {
             span: eii_attr_span,
@@ -74,23 +80,25 @@ fn eii_(
         return vec![item];
     };
 
-    let orig_item = item.clone();
-
-    let item = *item;
-
-    let ast::Item { attrs, id: _, span: _, vis, kind: ItemKind::Fn(func), tokens: _ } = item else {
+    let ast::Item { attrs, id: _, span: _, vis, kind: ItemKind::Fn(func), tokens: _ } =
+        item.as_ref()
+    else {
         ecx.dcx().emit_err(EiiSharedMacroExpectedFunction {
             span: eii_attr_span,
             name: path_to_string(&meta_item.path),
         });
-        return vec![Annotatable::Item(Box::new(item))];
+        return vec![wrap_item(item)];
     };
+    // only clone what we need
+    let attrs = attrs.clone();
+    let func = (**func).clone();
+    let vis = vis.clone();
 
     let attrs_from_decl =
         filter_attrs_for_multiple_eii_attr(ecx, attrs, eii_attr_span, &meta_item.path);
 
     let Ok(macro_name) = name_for_impl_macro(ecx, &func, &meta_item) else {
-        return vec![Annotatable::Item(orig_item)];
+        return vec![wrap_item(item)];
     };
 
     // span of the declaring item without attributes
@@ -115,7 +123,7 @@ fn eii_(
         ecx,
         eii_attr_span,
         item_span,
-        *func,
+        func,
         vis,
         &attrs_from_decl,
     )));
@@ -128,20 +136,7 @@ fn eii_(
         decl_span,
     )));
 
-    if stmt {
-        return_items
-            .into_iter()
-            .map(|i| {
-                Annotatable::Stmt(Box::new(Stmt {
-                    id: DUMMY_NODE_ID,
-                    kind: StmtKind::Item(i),
-                    span: eii_attr_span,
-                }))
-            })
-            .collect()
-    } else {
-        return_items.into_iter().map(|i| Annotatable::Item(i)).collect()
-    }
+    return_items.into_iter().map(wrap_item).collect()
 }
 
 /// Decide on the name of the macro that can be used to implement the EII.

compiler/rustc_graphviz/src/lib.rs

@@ -416,7 +416,7 @@ impl<'a> Id<'a> {
 /// it in the generated .dot file. They can also provide more
 /// elaborate (and non-unique) label text that is used in the graphviz
 /// rendered output.
-
+///
 /// The graph instance is responsible for providing the DOT compatible
 /// identifiers for the nodes and (optionally) rendered labels for the nodes and
 /// edges, as well as an identifier for the graph itself.

compiler/rustc_middle/src/ty/context.rs

@@ -2654,7 +2654,7 @@ struct InternedInSet<'tcx, T: ?Sized + PointeeSized>(&'tcx T);
 
 impl<'tcx, T: 'tcx + ?Sized + PointeeSized> Clone for InternedInSet<'tcx, T> {
     fn clone(&self) -> Self {
-        InternedInSet(self.0)
+        *self
     }
 }
 

compiler/rustc_pattern_analysis/src/lib.rs

@@ -141,7 +141,7 @@ pub struct MatchArm<'p, Cx: PatCx> {
 
 impl<'p, Cx: PatCx> Clone for MatchArm<'p, Cx> {
     fn clone(&self) -> Self {
-        Self { pat: self.pat, has_guard: self.has_guard, arm_data: self.arm_data }
+        *self
     }
 }
 

compiler/rustc_pattern_analysis/src/pat.rs

@@ -174,10 +174,7 @@ pub(crate) enum PatOrWild<'p, Cx: PatCx> {
 
 impl<'p, Cx: PatCx> Clone for PatOrWild<'p, Cx> {
     fn clone(&self) -> Self {
-        match self {
-            PatOrWild::Wild => PatOrWild::Wild,
-            PatOrWild::Pat(pat) => PatOrWild::Pat(pat),
-        }
+        *self
     }
 }
 

compiler/rustc_pattern_analysis/src/usefulness.rs

@@ -824,7 +824,7 @@ struct PlaceCtxt<'a, Cx: PatCx> {
 impl<'a, Cx: PatCx> Copy for PlaceCtxt<'a, Cx> {}
 impl<'a, Cx: PatCx> Clone for PlaceCtxt<'a, Cx> {
     fn clone(&self) -> Self {
-        Self { cx: self.cx, ty: self.ty }
+        *self
     }
 }
 

compiler/rustc_thread_pool/src/registry.rs

@@ -153,8 +153,8 @@ pub struct Registry {
     terminate_count: AtomicUsize,
 }
 
-/// ////////////////////////////////////////////////////////////////////////
-/// Initialization
+///////////////////////////////////////////////////////////////////////////
+// Initialization
 
 static mut THE_REGISTRY: Option<Arc<Registry>> = None;
 static THE_REGISTRY_SET: Once = Once::new();
@@ -407,12 +407,12 @@ impl Registry {
         }
     }
 
-    /// ////////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////////
     /// MAIN LOOP
     ///
     /// So long as all of the worker threads are hanging out in their
     /// top-level loop, there is no work to be done.
-
+    ///
     /// Push a job into the given `registry`. If we are running on a
     /// worker thread for the registry, this will push onto the
     /// deque. Else, it will inject from the outside (which is slower).
@@ -668,8 +668,8 @@ impl ThreadInfo {
     }
 }
 
-/// ////////////////////////////////////////////////////////////////////////
-/// WorkerThread identifiers
+///////////////////////////////////////////////////////////////////////////
+// WorkerThread identifiers
 
 pub(super) struct WorkerThread {
     /// the "worker" half of our local deque
@@ -1019,8 +1019,6 @@ impl WorkerThread {
     }
 }
 
-/// ////////////////////////////////////////////////////////////////////////
-
 unsafe fn main_loop(thread: ThreadBuilder) {
     let worker_thread = &WorkerThread::from(thread);
     unsafe { WorkerThread::set_current(worker_thread) };

library/core/src/cell/once.rs

@@ -353,7 +353,8 @@ impl<T> OnceCell<T> {
 }
 
 #[stable(feature = "once_cell", since = "1.70.0")]
-impl<T> Default for OnceCell<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
+impl<T> const Default for OnceCell<T> {
     #[inline]
     fn default() -> Self {
         Self::new()

library/core/src/prelude/v1.rs

@@ -118,13 +118,6 @@ pub use crate::macros::builtin::deref;
 )]
 pub use crate::macros::builtin::define_opaque;
 
-#[unstable(
-    feature = "derive_from",
-    issue = "144889",
-    reason = "`derive(From)` is unstable"
-)]
-pub use crate::macros::builtin::From;
-
 #[unstable(feature = "extern_item_impls", issue = "125418")]
 pub use crate::macros::builtin::{eii, unsafe_eii};
 

library/core/src/sync/atomic.rs

@@ -1151,8 +1151,8 @@ impl AtomicBool {
     /// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);
     /// assert_eq!(foo.load(Ordering::SeqCst), true);
     ///
-    /// let foo = AtomicBool::new(true);
-    /// assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);
+    /// let foo = AtomicBool::new(false);
+    /// assert_eq!(foo.fetch_or(true, Ordering::SeqCst), false);
     /// assert_eq!(foo.load(Ordering::SeqCst), true);
     ///
     /// let foo = AtomicBool::new(false);