Rollup of 12 pull requests

.mailmap

@@ -350,6 +350,7 @@ John Van Enk <vanenkj@gmail.com>
 Jon Gjengset <jon@thesquareplanet.com> <jongje@amazon.com>
 Jonas Tepe <jonasprogrammer@gmail.com>
 Jonathan Bailey <jbailey@mozilla.com> <jbailey@jbailey-20809.local>
+Jonathan Brouwer <jonathantbrouwer@gmail.com> <jonathan.brouwer@technolution.nl>
 Jonathan Chan Kwan Yin <sofe2038@gmail.com>
 Jonathan L <Xmasreturns@users.noreply.github.com>
 Jonathan S <gereeter@gmail.com> Jonathan S <gereeter+code@gmail.com>

compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp

@@ -1165,7 +1165,9 @@ extern "C" LLVMRustResult LLVMRustPrintModule(LLVMModuleRef M, const char *Path,
     LLVMRustSetLastError(ErrorInfo.c_str());
     return LLVMRustResult::Failure;
   }
-
+#if LLVM_VERSION_GE(24, 0)
+  unwrap(M)->renumberMetadataForAssembly();
+#endif
   auto AAW = RustAssemblyAnnotationWriter(Demangle);
   auto FOS = formatted_raw_ostream(OS);
   unwrap(M)->print(FOS, &AAW);

compiler/rustc_mir_build/src/builder/block.rs

@@ -207,12 +207,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         let else_block_span = this.thir[*else_block].span;
                         let (true_block, false_block) =
                             this.in_if_then_scope(last_remainder_scope, else_block_span, |this| {
-                                // Bypass `lower_if_condition` and call `lower_let_expr` directly,
+                                // Bypass `lower_if_condition` and call `lower_fallible_let` directly,
                                 // since we don't have an actual THIR let-expression here.
-                                this.lower_let_expr(
+                                this.lower_fallible_let(
                                     block,
-                                    *initializer,
                                     pattern,
+                                    *initializer,
                                     None,
                                     initializer_span,
                                     DeclareLetBindings::No,

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -50,7 +50,7 @@ pub(crate) struct LowerIfCondArgs {
     pub(crate) variable_source_info: SourceInfo,
     /// Determines how bindings should be handled when lowering `let` expressions.
     ///
-    /// Forwarded to [`Builder::lower_let_expr`] when lowering [`ExprKind::Let`].
+    /// Forwarded to [`Builder::lower_fallible_let`] when lowering [`ExprKind::Let`].
     pub(crate) declare_let_bindings: DeclareLetBindings,
 }
 
@@ -62,9 +62,9 @@ impl LowerIfCondArgs {
     }
 }
 
-/// Should lowering a `let` expression also declare its bindings?
+/// Should lowering a `let` also declare its bindings?
 ///
-/// Used by [`Builder::lower_let_expr`] when lowering [`ExprKind::Let`].
+/// Used by [`Builder::lower_fallible_let`].
 #[derive(Clone, Copy)]
 pub(crate) enum DeclareLetBindings {
     /// Yes, declare `let` bindings as normal for `if` conditions.
@@ -169,10 +169,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 })
             }
             ExprKind::ValueExpr { source } => this.lower_if_condition(block, source, args),
-            ExprKind::Let { expr, ref pat } => this.lower_let_expr(
+            ExprKind::Let { ref pat, expr } => this.lower_fallible_let(
                 block,
-                expr,
                 pat,
+                expr,
                 Some(args.variable_source_info.scope),
                 args.variable_source_info.span,
                 args.declare_let_bindings,
@@ -2309,65 +2309,72 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 // Pat binding - used for `let` and function parameters as well.
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
-    /// Lowers a `let` expression that appears in a suitable context
-    /// (e.g. an `if` condition or match guard).
-    ///
-    /// Also used for lowering let-else statements, since they have similar
-    /// needs despite not actually using `let` expressions.
+    /// Lowers a fallible `let`, which is one of:
+    /// - A let-expression inside an `if` condition or match guard.
+    /// - A let-else statement.
     ///
-    /// Use [`DeclareLetBindings`] to control whether the `let` bindings are
-    /// declared or not.
+    /// (Strictly speaking, the underlying pattern might actually be infallible.
+    /// What matters here is that it is _allowed_ to be fallible.)
     ///
     /// Must be called within a [`Builder::in_if_then_scope`], to indicate where
     /// to break to if the `let` fails to match.
-    pub(crate) fn lower_let_expr(
+    pub(crate) fn lower_fallible_let(
         &mut self,
         mut block: BasicBlock,
-        expr_id: ExprId,
         pat: &Pat<'tcx>,
+        scrutinee_id: ExprId,
         source_scope: Option<SourceScope>,
         scope_span: Span,
+        // Controls whether bindings are declared or not, as requested by the caller.
         declare_let_bindings: DeclareLetBindings,
     ) -> BlockAnd<()> {
-        let expr_span = self.thir[expr_id].span;
-        let scrutinee = unpack!(block = self.lower_scrutinee(block, expr_id));
+        let scrutinee_span = self.thir[scrutinee_id].span;
+        let scrutinee_place_builder = unpack!(block = self.lower_scrutinee(block, scrutinee_id));
+
+        // Lower the scrutinee and pattern as though they were desugared to a `match`.
         let built_tree = self.lower_match_tree(
             block,
-            expr_span,
-            &scrutinee,
+            scrutinee_span,
+            &scrutinee_place_builder,
             pat.span,
             vec![(pat, HasMatchGuard::No)],
             Exhaustive::No,
         );
-        let [branch] = built_tree.branches.try_into().unwrap();
+        let [true_branch] = built_tree.branches.try_into().unwrap();
+        let false_block = built_tree.otherwise_block;
 
         // If pattern-matching failed, break out of the enclosing if-then scope.
-        self.break_from_if_then_scope(built_tree.otherwise_block, self.source_info(expr_span));
+        self.break_from_if_then_scope(false_block, self.source_info(scrutinee_span));
 
         match declare_let_bindings {
             DeclareLetBindings::Yes => {
-                let expr_place = scrutinee.try_to_place(self);
-                let opt_expr_place = expr_place.as_ref().map(|place| (Some(place), expr_span));
+                let scrutinee_place;
+                let opt_match_place = try {
+                    scrutinee_place = scrutinee_place_builder.try_to_place(self)?;
+                    (Some(&scrutinee_place), scrutinee_span)
+                };
                 self.declare_bindings(
                     source_scope,
                     pat.span.to(scope_span),
                     pat,
                     None,
-                    opt_expr_place,
+                    opt_match_place,
                 );
             }
             DeclareLetBindings::No => {} // Caller is responsible for bindings.
-            DeclareLetBindings::LetNotPermitted => {
-                self.tcx.dcx().span_bug(expr_span, "let expression not expected in this context")
-            }
+            DeclareLetBindings::LetNotPermitted => self
+                .tcx
+                .dcx()
+                .span_bug(scrutinee_span, "let expression not expected in this context"),
         }
 
-        let success = self.bind_pattern(self.source_info(pat.span), branch, &[], expr_span, None);
+        let true_block =
+            self.bind_pattern(self.source_info(pat.span), true_branch, &[], scrutinee_span, None);
 
         // If branch coverage is enabled, record this branch.
-        self.visit_coverage_conditional_let(pat, success, built_tree.otherwise_block);
+        self.visit_coverage_conditional_let(pat, true_block, false_block);
 
-        success.unit()
+        true_block.unit()
     }
 
     /// Initializes each of the bindings from the candidate by

compiler/rustc_passes/src/dead.rs

@@ -601,15 +601,12 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
         {
             if defer_seeds_come_from_allow {
                 return ImplItemCheckResult::Dead { require: adt_def_id };
-            } else {
-                let comes_from_allow = trait_comes_from_allow
-                    .or_else(|| has_allow_dead_code_or_lang_attr(self.tcx, adt_def_id));
-
-                return match comes_from_allow {
-                    Some(comes_from_allow) => ImplItemCheckResult::Live(comes_from_allow),
-                    None => ImplItemCheckResult::Dead { require: adt_def_id },
-                };
             }
+
+            return match trait_comes_from_allow {
+                Some(comes_from_allow) => ImplItemCheckResult::Live(comes_from_allow),
+                None => ImplItemCheckResult::Dead { require: adt_def_id },
+            };
         }
 
         ImplItemCheckResult::Live(ComesFromAllowExpect::No)

compiler/rustc_type_ir_macros/src/lib.rs

@@ -48,11 +48,15 @@ decl_derive!(
         /// struct Foo {
         ///     #[generic_type_visitable(bounds())]
         ///     just_self: Box<Self>,
-        ///     #[generic_type_visitable(bounds(Bar: GenericTypeVisitable))]
+        ///     #[generic_type_visitable(bounds(Bar: GenericTypeVisitable<__V>))]
         ///     contains_self: (Box<Self>, Bar),
         /// }
         /// struct Bar;
         /// ```
+        ///
+        /// Note: the `__V` lifetime is an implementation detail of the derive macro.
+        /// We could probably handle this in a nicer way, but we don't expect this form
+        /// to really be necessary any time soon, so for now we don't.
         customizable_type_visitable_derive
 );
 
@@ -461,7 +465,7 @@ mod kw {
 /// Parses a bound like:
 ///
 /// ```ignore (would need to import GenericTypeVisitable to get this to compile)
-/// #[generic_type_visitable(bounds(Foo: GenericTypeVisitable, Bar: GenericTypeVisitable))]
+/// #[generic_type_visitable(bounds(Foo: GenericTypeVisitable<__V>, Bar: GenericTypeVisitable<__V>))]
 /// ```
 fn parse_generic_type_visitable_bound(
     attr: &Attribute,

library/alloc/src/collections/vec_deque/mod.rs

@@ -949,6 +949,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// `Vec::from_raw_parts_in`, but takes a *range* of elements that are
     /// initialized rather than only supporting `0..len`.  Requires that
     /// `initialized.start` ≤ `initialized.end` ≤ `capacity`.
+    /// Also, `initialized.start` < `capacity`, unless both are 0.
     #[inline]
     #[cfg(not(test))]
     pub(crate) unsafe fn from_contiguous_raw_parts_in(
@@ -959,9 +960,13 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ) -> Self {
         debug_assert!(initialized.start <= initialized.end);
         debug_assert!(initialized.end <= capacity);
+        debug_assert!(initialized.start == 0 && capacity == 0 || initialized.start < capacity);
 
         // SAFETY: Our safety precondition guarantees the range length won't wrap,
-        // and that the allocation is valid for use in `RawVec`.
+        // that the allocation is valid for use in `RawVec` with `alloc`,
+        // and that the range contains valid elements.
+        // We have `head`, `len` ≤ `cap`, since `start`, `end` ≤ `cap`.
+        // Also, `head` < `cap` unless `head` = `cap` = `0`.
         unsafe {
             VecDeque {
                 head: WrappedIndex::from_arbitrary_number(initialized.start),

library/alloc/src/vec/into_iter.rs

@@ -213,25 +213,39 @@ impl<T, A: Allocator> IntoIter<T, A> {
         // Keep our `Drop` impl from dropping the elements and the allocator
         let mut this = ManuallyDrop::new(self);
 
-        // SAFETY: This allocation originally came from a `Vec`, so it passes
-        // all those checks. We have `this.buf` ≤ `this.ptr` ≤ `this.end`,
-        // so the `offset_from_unsigned`s below cannot wrap, and will produce a well-formed
-        // range. `end` ≤ `buf + cap`, so the range will be in-bounds.
-        // Taking `alloc` is ok because nothing else is going to look at it,
-        // since our `Drop` impl isn't going to run so there's no more code.
-        unsafe {
-            let buf = this.buf.as_ptr();
-            let initialized = if T::IS_ZST {
-                // All the pointers are the same for ZSTs, so it's fine to
-                // say that they're all at the beginning of the "allocation".
-                0..this.len()
-            } else {
-                this.ptr.offset_from_unsigned(this.buf)..this.end.offset_from_unsigned(buf)
-            };
-            let cap = this.cap;
-            let alloc = ManuallyDrop::take(&mut this.alloc);
-            VecDeque::from_contiguous_raw_parts_in(buf, initialized, cap, alloc)
-        }
+        let buf = this.buf.as_ptr();
+        let initialized = if T::IS_ZST || this.len() == 0 {
+            // All the pointers are the same for ZSTs, so it's fine to
+            // say that they're all at the beginning of the "allocation".
+            // For non-ZSTs, we have length 0, so we can choose the (empty)
+            // range to be at the start of the buffer.
+            //
+            // Due to `0` ≤ `this.len()` ≤ `this.cap`, the range is well-formed,
+            // and due to the argument above it spans exactly the elements of
+            // this iterator. Because `init.start` = `0`, it follows that either
+            // `init.start` < `cap` or `cap` = `init.start` = `0`; thus the range
+            // satisfies the requirements of `from_contiguous_raw_parts_in`.
+            0..this.len()
+        } else {
+            // SAFETY: `this.ptr` and `this.end` are created via offsets of `this.buf`,
+            // so they point to the same allocation. We have `this.buf` ≤ `this.ptr` ≤ `this.end`,
+            // so this cannot wrap, and will produce a well-formed range that spans exactly
+            // the elements of this iterator.
+            //
+            // Additionally, due to `end ≤ buf + cap`, we have `init.start` ≤ `init.end` ≤ `cap`.
+            // Due to the length check above, `init.start < cap`, so the range satisfies the
+            // requirements of `from_contiguous_raw_parts_in`.
+            unsafe { this.ptr.offset_from_unsigned(this.buf)..this.end.offset_from_unsigned(buf) }
+        };
+
+        let cap = this.cap;
+        // SAFETY: `this` is forgotten afterwards, so we can move out the allocator.
+        let alloc = unsafe { ManuallyDrop::take(&mut this.alloc) };
+
+        // SAFETY: This allocation originally came from a `Vec`, so it satisfies all
+        // requirements for the `buf` pointer with capacity `cap` allocated in `alloc`.
+        // Correctness of `initialized` was shown above.
+        unsafe { VecDeque::from_contiguous_raw_parts_in(buf, initialized, cap, alloc) }
     }
 }
 

library/alloctests/tests/vec_deque.rs

@@ -2495,3 +2495,18 @@ fn truncate_to_range_inclusive_end_overflow() {
     let mut v: VecDeque<_> = (0..6).collect();
     v.truncate_to_range(0..=usize::MAX);
 }
+
+#[test]
+fn issue_162452_vec_deque_from_empty_vec_into_iter() {
+    for n in 1..20 {
+        let v = Vec::from_iter(0..n);
+
+        let mut it = v.into_iter();
+        for _ in &mut it {}
+
+        let mut d: VecDeque<_> = it.collect();
+
+        d.push_back(n);
+        assert_eq!(Some(n), d.pop_front());
+    }
+}

library/core/src/time.rs

@@ -345,7 +345,7 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of weeks.
     ///
-    /// For this method, one week is defined as 7 days, or 604,800 seconds.
+    /// For this function, one week is defined as 7 days, or 604,800 seconds.
     ///
     /// # Panics
     ///
@@ -375,7 +375,7 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of days.
     ///
-    /// For this method, one day is defined as 24 hours, or 86,400 seconds.
+    /// For this function, one day is defined as 24 hours, or 86,400 seconds.
     ///
     /// # Panics
     ///
@@ -405,7 +405,7 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of hours.
     ///
-    /// For this method, one hour is defined as 60 minutes, or 3,600 seconds.
+    /// For this function, one hour is defined as 60 minutes, or 3,600 seconds.
     ///
     /// # Panics
     ///
@@ -435,7 +435,7 @@ impl Duration {
 
     /// Creates a new `Duration` from the specified number of minutes.
     ///
-    /// For this method, one minute is defined as 60 seconds.
+    /// For this function, one minute is defined as 60 seconds.
     ///
     /// # Panics
     ///