Rollup of 7 pull requests

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);

library/std/src/lib.rs

@@ -274,6 +274,7 @@
 #![feature(cfg_sanitizer_cfi)]
 #![feature(cfg_target_thread_local)]
 #![feature(cfi_encoding)]
+#![feature(const_default)]
 #![feature(const_trait_impl)]
 #![feature(core_float_math)]
 #![feature(decl_macro)]

library/std/src/sync/once_lock.rs

@@ -582,7 +582,8 @@ impl<T: RefUnwindSafe + UnwindSafe> RefUnwindSafe for OnceLock<T> {}
 impl<T: UnwindSafe> UnwindSafe for OnceLock<T> {}
 
 #[stable(feature = "once_cell", since = "1.70.0")]
-impl<T> Default for OnceLock<T> {
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
+impl<T> const Default for OnceLock<T> {
     /// Creates a new uninitialized cell.
     ///
     /// # Example

library/test/src/formatters/junit.rs

@@ -189,8 +189,10 @@ impl<T: Write> OutputFormatter for JunitFormatter<T> {
         compilation_time: f64,
     ) -> io::Result<()> {
         self.write_message(&format!(
-            "<report total_time=\"{total_time}\" compilation_time=\"{compilation_time}\"></report>\n",
-        ))
+            "<report total_time=\"{total_time}\" compilation_time=\"{compilation_time}\"></report>",
+        ))?;
+        self.out.write_all(b"\n")?;
+        Ok(())
     }
 }
 

src/etc/gdb_lookup.py

@@ -3,7 +3,7 @@
 import re
 
 from gdb_providers import *
-from rust_types import *
+from rust_types import RustType, classify_struct, classify_union
 
 
 _gdb_version_matched = re.search("([0-9]+)\\.([0-9]+)", gdb.VERSION)
@@ -28,7 +28,7 @@ def classify_rust_type(type):
     if type_class == gdb.TYPE_CODE_UNION:
         return classify_union(type.fields())
 
-    return RustType.OTHER
+    return RustType.Other
 
 
 def check_enum_discriminant(valobj):
@@ -85,7 +85,7 @@ def __init__(self, name):
 
     def add(self, rust_type, provider):
         # Just use the rust_type as the name.
-        printer = PrintByRustType(rust_type, provider)
+        printer = PrintByRustType(rust_type.name, provider)
         self.type_map[rust_type] = printer
         self.subprinters.append(printer)
 
@@ -99,23 +99,23 @@ def __call__(self, valobj):
 printer = RustPrettyPrinter("rust")
 # use enum provider only for GDB <7.12
 if gdb_version[0] < 7 or (gdb_version[0] == 7 and gdb_version[1] < 12):
-    printer.add(RustType.ENUM, enum_provider)
-printer.add(RustType.STD_STRING, StdStringProvider)
-printer.add(RustType.STD_OS_STRING, StdOsStringProvider)
-printer.add(RustType.STD_STR, StdStrProvider)
-printer.add(RustType.STD_SLICE, StdSliceProvider)
-printer.add(RustType.STD_VEC, StdVecProvider)
-printer.add(RustType.STD_VEC_DEQUE, StdVecDequeProvider)
-printer.add(RustType.STD_BTREE_SET, StdBTreeSetProvider)
-printer.add(RustType.STD_BTREE_MAP, StdBTreeMapProvider)
-printer.add(RustType.STD_HASH_MAP, hashmap_provider)
-printer.add(RustType.STD_HASH_SET, hashset_provider)
-printer.add(RustType.STD_RC, StdRcProvider)
-printer.add(RustType.STD_ARC, lambda valobj: StdRcProvider(valobj, is_atomic=True))
-
-printer.add(RustType.STD_CELL, StdCellProvider)
-printer.add(RustType.STD_REF, StdRefProvider)
-printer.add(RustType.STD_REF_MUT, StdRefProvider)
-printer.add(RustType.STD_REF_CELL, StdRefCellProvider)
-
-printer.add(RustType.STD_NONZERO_NUMBER, StdNonZeroNumberProvider)
+    printer.add(RustType.Enum, enum_provider)
+printer.add(RustType.StdString, StdStringProvider)
+printer.add(RustType.StdOsString, StdOsStringProvider)
+printer.add(RustType.StdStr, StdStrProvider)
+printer.add(RustType.StdSlice, StdSliceProvider)
+printer.add(RustType.StdVec, StdVecProvider)
+printer.add(RustType.StdVecDeque, StdVecDequeProvider)
+printer.add(RustType.StdBTreeSet, StdBTreeSetProvider)
+printer.add(RustType.StdBTreeMap, StdBTreeMapProvider)
+printer.add(RustType.StdHashMap, hashmap_provider)
+printer.add(RustType.StdHashSet, hashset_provider)
+printer.add(RustType.StdRc, StdRcProvider)
+printer.add(RustType.StdArc, lambda valobj: StdRcProvider(valobj, is_atomic=True))
+
+printer.add(RustType.StdCell, StdCellProvider)
+printer.add(RustType.StdRef, StdRefProvider)
+printer.add(RustType.StdRefMut, StdRefProvider)
+printer.add(RustType.StdRefCell, StdRefCellProvider)
+
+printer.add(RustType.StdNonZeroNumber, StdNonZeroNumberProvider)