Rollup of 8 pull requests

compiler/rustc_monomorphize/src/partitioning.rs

@@ -254,8 +254,9 @@ where
             always_export_generics,
         );
 
-        // We can't differentiate something that got inlined.
+        // We can't differentiate a function that got inlined.
         let autodiff_active = cfg!(llvm_enzyme)
+            && matches!(mono_item, MonoItem::Fn(_))
             && cx
                 .tcx
                 .codegen_fn_attrs(mono_item.def_id())

compiler/rustc_session/src/code_stats.rs

@@ -72,6 +72,8 @@ pub struct TypeSizeInfo {
 
 #[derive(Default)]
 pub struct CodeStats {
+    /// The hash set that actually holds all the type size information.
+    /// The field is public for use in external tools. See #139876.
     pub type_sizes: Lock<FxHashSet<TypeSizeInfo>>,
 }
 

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -77,7 +77,15 @@ impl<'tcx> At<'_, 'tcx> {
                 .into_value_registering_obligations(self.infcx, &mut *fulfill_cx);
             let errors = fulfill_cx.select_all_or_error(self.infcx);
             let value = self.infcx.resolve_vars_if_possible(value);
-            if errors.is_empty() { Ok(value) } else { Err(errors) }
+            if errors.is_empty() {
+                Ok(value)
+            } else {
+                // Drop pending obligations, since deep normalization may happen
+                // in a loop and we don't want to trigger the assertion on the next
+                // iteration due to pending ambiguous obligations we've left over.
+                let _ = fulfill_cx.collect_remaining_errors(self.infcx);
+                Err(errors)
+            }
         }
     }
 }

library/core/src/any.rs

@@ -772,8 +772,8 @@ impl hash::Hash for TypeId {
         //   (especially given the previous point about the lower 64 bits being
         //   high quality on their own).
         // - It is correct to do so -- only hashing a subset of `self` is still
-        //   with an `Eq` implementation that considers the entire value, as
-        //   ours does.
+        //   compatible with an `Eq` implementation that considers the entire
+        //   value, as ours does.
         self.t.1.hash(state);
     }
 }

library/std/src/rt.rs

@@ -46,7 +46,7 @@ macro_rules! rtprintpanic {
 macro_rules! rtabort {
     ($($t:tt)*) => {
         {
-            rtprintpanic!("fatal runtime error: {}\n", format_args!($($t)*));
+            rtprintpanic!("fatal runtime error: {}, aborting\n", format_args!($($t)*));
             crate::sys::abort_internal();
         }
     }

library/std/src/thread/local.rs

@@ -22,12 +22,16 @@ use crate::fmt;
 ///
 /// Initialization is dynamically performed on the first call to a setter (e.g.
 /// [`with`]) within a thread, and values that implement [`Drop`] get
-/// destructed when a thread exits. Some caveats apply, which are explained below.
+/// destructed when a thread exits. Some platform-specific caveats apply, which
+/// are explained below.
+/// Note that, should the destructor panics, the whole process will be [aborted].
 ///
 /// A `LocalKey`'s initializer cannot recursively depend on itself. Using a
 /// `LocalKey` in this way may cause panics, aborts or infinite recursion on
 /// the first call to `with`.
 ///
+/// [aborted]: crate::process::abort
+///
 /// # Single-thread Synchronization
 ///
 /// Though there is no potential race with other threads, it is still possible to

library/std/src/time.rs

@@ -205,8 +205,8 @@ pub struct Instant(time::Instant);
 ///            println!("{}", elapsed.as_secs());
 ///        }
 ///        Err(e) => {
-///            // an error occurred!
-///            println!("Error: {e:?}");
+///            // the system clock went backwards!
+///            println!("Great Scott! {e:?}");
 ///        }
 ///    }
 /// }
@@ -245,6 +245,7 @@ pub struct Instant(time::Instant);
 /// > structure cannot represent the new point in time.
 ///
 /// [`add`]: SystemTime::add
+/// [`UNIX_EPOCH`]: SystemTime::UNIX_EPOCH
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[stable(feature = "time2", since = "1.8.0")]
 pub struct SystemTime(time::SystemTime);

src/tools/compiletest/src/runtest.rs

@@ -1395,14 +1395,6 @@ impl<'test> TestCx<'test> {
         matches!(self.config.suite.as_str(), "rustdoc-ui" | "rustdoc-js" | "rustdoc-json")
     }
 
-    fn get_mir_dump_dir(&self) -> Utf8PathBuf {
-        let mut mir_dump_dir = self.config.build_test_suite_root.clone();
-        debug!("input_file: {}", self.testpaths.file);
-        mir_dump_dir.push(&self.testpaths.relative_dir);
-        mir_dump_dir.push(self.testpaths.file.file_stem().unwrap());
-        mir_dump_dir
-    }
-
     fn make_compile_args(
         &self,
         input_file: &Utf8Path,
@@ -1511,10 +1503,7 @@ impl<'test> TestCx<'test> {
         }
 
         let set_mir_dump_dir = |rustc: &mut Command| {
-            let mir_dump_dir = self.get_mir_dump_dir();
-            remove_and_create_dir_all(&mir_dump_dir).unwrap_or_else(|e| {
-                panic!("failed to remove and recreate output directory `{mir_dump_dir}`: {e}")
-            });
+            let mir_dump_dir = self.output_base_dir();
             let mut dir_opt = "-Zdump-mir-dir=".to_string();
             dir_opt.push_str(mir_dump_dir.as_str());
             debug!("dir_opt: {:?}", dir_opt);

src/tools/compiletest/src/runtest/mir_opt.rs

@@ -56,7 +56,7 @@ impl TestCx<'_> {
                 self.diff_mir_files(from_file.into(), after.into())
             } else {
                 let mut output_file = Utf8PathBuf::new();
-                output_file.push(self.get_mir_dump_dir());
+                output_file.push(self.output_base_dir());
                 output_file.push(&from_file);
                 debug!("comparing the contents of: {} with {:?}", output_file, expected_file);
                 if !output_file.exists() {
@@ -100,7 +100,7 @@ impl TestCx<'_> {
 
     fn diff_mir_files(&self, before: Utf8PathBuf, after: Utf8PathBuf) -> String {
         let to_full_path = |path: Utf8PathBuf| {
-            let full = self.get_mir_dump_dir().join(&path);
+            let full = self.output_base_dir().join(&path);
             if !full.exists() {
                 panic!(
                     "the mir dump file for {} does not exist (requested in {})",

src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr

@@ -1,7 +1,7 @@
 
 thread $NAME panicked at tests/fail/panic/tls_macro_const_drop_panic.rs:LL:CC:
 ow
-fatal runtime error: thread local panicked on drop
+fatal runtime error: thread local panicked on drop, aborting
 error: abnormal termination: the program aborted execution
 
 error: aborting due to 1 previous error

src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr

@@ -1,7 +1,7 @@
 
 thread $NAME panicked at tests/fail/panic/tls_macro_drop_panic.rs:LL:CC:
 ow
-fatal runtime error: thread local panicked on drop
+fatal runtime error: thread local panicked on drop, aborting
 error: abnormal termination: the program aborted execution
 
 error: aborting due to 1 previous error

tests/ui/or-patterns/lazy-and-or.rs

@@ -0,0 +1,25 @@
+//@ run-pass
+// This test verifies the short-circuiting behavior of logical operators `||` and `&&`.
+// It ensures that the right-hand expression is not evaluated when the left-hand
+// expression is sufficient to determine the result.
+
+fn would_panic_if_called(x: &mut isize) -> bool {
+    *x += 1;
+    assert!(false, "This function should never be called due to short-circuiting");
+    false
+}
+
+fn main() {
+    let x = 1 == 2 || 3 == 3;
+    assert!(x);
+
+    let mut y: isize = 10;
+    println!("Result of short-circuit: {}", x || would_panic_if_called(&mut y));
+    assert_eq!(y, 10, "y should remain 10 if short-circuiting works correctly");
+
+    if true && x {
+        assert!(true);
+    } else {
+        assert!(false, "This branch should not be reached");
+    }
+}

tests/ui/recursion/recursive-enum-box.rs

@@ -0,0 +1,21 @@
+//@ run-pass
+// A smoke test for recursive enum structures using Box<T>.
+// This test constructs a linked list-like structure to exercise memory allocation and ownership.
+// Originally introduced in 2010, this is one of Rust’s earliest test cases.
+
+#![allow(dead_code)]
+
+enum List {
+    Cons(isize, Box<List>),
+    Nil,
+}
+
+fn main() {
+    List::Cons(
+        10,
+        Box::new(List::Cons(
+            11,
+            Box::new(List::Cons(12, Box::new(List::Nil))),
+        )),
+    );
+}

tests/ui/runtime/rt-explody-panic-payloads.rs

@@ -27,6 +27,6 @@ fn main() {
             // by QEMU in the stderr whenever a core dump happens. Remove it before the check.
             v.strip_suffix("qemu: uncaught target signal 6 (Aborted) - core dumped\n").unwrap_or(v)
         })
-        .map(|v| { v.ends_with("fatal runtime error: drop of the panic payload panicked\n") })
+        .map(|v| v.ends_with("fatal runtime error: drop of the panic payload panicked, aborting\n"))
         .unwrap_or(false));
 }

tests/ui/traits/deep-norm-pending.rs

@@ -0,0 +1,24 @@
+trait Foo {
+    type Assoc;
+}
+
+trait Bar {
+    fn method() -> impl Sized;
+    //~^ ERROR the trait bound `T: Foo` is not satisfied
+}
+impl<T> Bar for T
+//~^ ERROR the trait bound `T: Foo` is not satisfied
+//~| ERROR the trait bound `T: Foo` is not satisfied
+where
+    <T as Foo>::Assoc: Sized,
+{
+    fn method() {}
+    //~^ ERROR the trait bound `T: Foo` is not satisfied
+    //~| ERROR the trait bound `T: Foo` is not satisfied
+    //~| ERROR the trait bound `T: Foo` is not satisfied
+    //~| ERROR the trait bound `T: Foo` is not satisfied
+    //~| ERROR the trait bound `T: Foo` is not satisfied
+    //~| ERROR the trait bound `T: Foo` is not satisfied
+}
+
+fn main() {}