Auto merge of rust-lang#147475 - matthiaskrgr:rollup-iyrkv0g, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - rust-lang#144006 (clarify wording of match ergonomics diagnostics (`rust_2024_incompatible_pat` lint and error))
 - rust-lang#147386 (some more `proc_macro` cleanups)
 - rust-lang#147412 (Convert impossible cases in macro resolution into assertions)
 - rust-lang#147464 (prefer repeat_n() over repeat().take())
 - rust-lang#147469 (Add rustdoc crate name in error)
 - rust-lang#147472 (refactor: replace `LLVMRustAtomicLoad/Store` with LLVM built-in functions)

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

Author: bors

compiler/rustc_codegen_llvm/src/builder.rs

@@ -639,13 +639,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         size: Size,
     ) -> &'ll Value {
         unsafe {
-            let load = llvm::LLVMRustBuildAtomicLoad(
-                self.llbuilder,
-                ty,
-                ptr,
-                UNNAMED,
-                AtomicOrdering::from_generic(order),
-            );
+            let load = llvm::LLVMBuildLoad2(self.llbuilder, ty, ptr, UNNAMED);
+            // Set atomic ordering
+            llvm::LLVMSetOrdering(load, AtomicOrdering::from_generic(order));
             // LLVM requires the alignment of atomic loads to be at least the size of the type.
             llvm::LLVMSetAlignment(load, size.bytes() as c_uint);
             load
@@ -872,12 +868,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         debug!("Store {:?} -> {:?}", val, ptr);
         assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
         unsafe {
-            let store = llvm::LLVMRustBuildAtomicStore(
-                self.llbuilder,
-                val,
-                ptr,
-                AtomicOrdering::from_generic(order),
-            );
+            let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
+            // Set atomic ordering
+            llvm::LLVMSetOrdering(store, AtomicOrdering::from_generic(order));
             // LLVM requires the alignment of atomic stores to be at least the size of the type.
             llvm::LLVMSetAlignment(store, size.bytes() as c_uint);
         }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1151,6 +1151,7 @@ unsafe extern "C" {
 
     // Operations on load/store instructions (only)
     pub(crate) fn LLVMSetVolatile(MemoryAccessInst: &Value, volatile: Bool);
+    pub(crate) fn LLVMSetOrdering(MemoryAccessInst: &Value, Ordering: AtomicOrdering);
 
     // Operations on phi nodes
     pub(crate) fn LLVMAddIncoming<'a>(
@@ -2090,22 +2091,6 @@ unsafe extern "C" {
         RHS: &'a Value,
     ) -> &'a Value;
 
-    // Atomic Operations
-    pub(crate) fn LLVMRustBuildAtomicLoad<'a>(
-        B: &Builder<'a>,
-        ElementType: &'a Type,
-        PointerVal: &'a Value,
-        Name: *const c_char,
-        Order: AtomicOrdering,
-    ) -> &'a Value;
-
-    pub(crate) fn LLVMRustBuildAtomicStore<'a>(
-        B: &Builder<'a>,
-        Val: &'a Value,
-        Ptr: &'a Value,
-        Order: AtomicOrdering,
-    ) -> &'a Value;
-
     pub(crate) fn LLVMRustTimeTraceProfilerInitialize();
 
     pub(crate) fn LLVMRustTimeTraceProfilerFinishThread();

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -878,7 +878,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             .compute_size_in_bytes(layout.size, count)
             .ok_or_else(|| err_ub_custom!(fluent::const_eval_size_overflow, name = name))?;
 
-        let bytes = std::iter::repeat(byte).take(len.bytes_usize());
+        let bytes = std::iter::repeat_n(byte, len.bytes_usize());
         self.write_bytes_ptr(dst, bytes)
     }
 

compiler/rustc_hir_typeck/src/pat.rs

@@ -3115,20 +3115,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // binding mode. This keeps it from making those suggestions, as doing so could panic.
         let info = table.entry(pat_id).or_insert_with(|| ty::Rust2024IncompatiblePatInfo {
             primary_labels: Vec::new(),
-            bad_modifiers: false,
+            bad_ref_modifiers: false,
+            bad_mut_modifiers: false,
             bad_ref_pats: false,
             suggest_eliding_modes: !self.tcx.features().ref_pat_eat_one_layer_2024()
                 && !self.tcx.features().ref_pat_eat_one_layer_2024_structural(),
         });
 
         let pat_kind = if let PatKind::Binding(user_bind_annot, _, _, _) = subpat.kind {
-            info.bad_modifiers = true;
             // If the user-provided binding modifier doesn't match the default binding mode, we'll
             // need to suggest reference patterns, which can affect other bindings.
             // For simplicity, we opt to suggest making the pattern fully explicit.
             info.suggest_eliding_modes &=
                 user_bind_annot == BindingMode(ByRef::Yes(def_br_mutbl), Mutability::Not);
-            "binding modifier"
+            if user_bind_annot == BindingMode(ByRef::No, Mutability::Mut) {
+                info.bad_mut_modifiers = true;
+                "`mut` binding modifier"
+            } else {
+                info.bad_ref_modifiers = true;
+                match user_bind_annot.1 {
+                    Mutability::Not => "explicit `ref` binding modifier",
+                    Mutability::Mut => "explicit `ref mut` binding modifier",
+                }
+            }
         } else {
             info.bad_ref_pats = true;
             // For simplicity, we don't try to suggest eliding reference patterns. Thus, we'll
@@ -3147,11 +3156,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // so, we may want to inspect the span's source callee or macro backtrace.
             "occurs within macro expansion".to_owned()
         } else {
-            let dbm_str = match def_br_mutbl {
-                Mutability::Not => "ref",
-                Mutability::Mut => "ref mut",
-            };
-            format!("{pat_kind} not allowed under `{dbm_str}` default binding mode")
+            format!("{pat_kind} not allowed when implicitly borrowing")
         };
         info.primary_labels.push((trimmed_span, primary_label));
     }

compiler/rustc_lint_defs/src/builtin.rs

@@ -1601,7 +1601,7 @@ declare_lint! {
     "detects patterns whose meaning will change in Rust 2024",
     @future_incompatible = FutureIncompatibleInfo {
         reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
-        reference: "<https://doc.rust-lang.org/nightly/edition-guide/rust-2024/match-ergonomics.html>",
+        reference: "<https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>",
     };
 }
 

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -60,29 +60,6 @@ using namespace llvm::object;
 static_assert(dwarf::DW_OP_LLVM_fragment == 0x1000);
 static_assert(dwarf::DW_OP_stack_value == 0x9f);
 
-// LLVMAtomicOrdering is already an enum - don't create another
-// one.
-static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
-  switch (Ordering) {
-  case LLVMAtomicOrderingNotAtomic:
-    return AtomicOrdering::NotAtomic;
-  case LLVMAtomicOrderingUnordered:
-    return AtomicOrdering::Unordered;
-  case LLVMAtomicOrderingMonotonic:
-    return AtomicOrdering::Monotonic;
-  case LLVMAtomicOrderingAcquire:
-    return AtomicOrdering::Acquire;
-  case LLVMAtomicOrderingRelease:
-    return AtomicOrdering::Release;
-  case LLVMAtomicOrderingAcquireRelease:
-    return AtomicOrdering::AcquireRelease;
-  case LLVMAtomicOrderingSequentiallyConsistent:
-    return AtomicOrdering::SequentiallyConsistent;
-  }
-
-  report_fatal_error("Invalid LLVMAtomicOrdering value!");
-}
-
 static LLVM_THREAD_LOCAL char *LastError;
 
 // Custom error handler for fatal LLVM errors.
@@ -623,24 +600,6 @@ extern "C" void LLVMRustSetAllowReassoc(LLVMValueRef V) {
   }
 }
 
-extern "C" LLVMValueRef
-LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source,
-                        const char *Name, LLVMAtomicOrdering Order) {
-  Value *Ptr = unwrap(Source);
-  LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name);
-  LI->setAtomic(fromRust(Order));
-  return wrap(LI);
-}
-
-extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
-                                                 LLVMValueRef V,
-                                                 LLVMValueRef Target,
-                                                 LLVMAtomicOrdering Order) {
-  StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target));
-  SI->setAtomic(fromRust(Order));
-  return wrap(SI);
-}
-
 extern "C" uint64_t LLVMRustGetArrayNumElements(LLVMTypeRef Ty) {
   return unwrap(Ty)->getArrayNumElements();
 }

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -858,8 +858,10 @@ impl<'tcx> std::fmt::Display for UserTypeKind<'tcx> {
 pub struct Rust2024IncompatiblePatInfo {
     /// Labeled spans for `&`s, `&mut`s, and binding modifiers incompatible with Rust 2024.
     pub primary_labels: Vec<(Span, String)>,
-    /// Whether any binding modifiers occur under a non-`move` default binding mode.
-    pub bad_modifiers: bool,
+    /// Whether any `mut` binding modifiers occur under a non-`move` default binding mode.
+    pub bad_mut_modifiers: bool,
+    /// Whether any `ref`/`ref mut` binding modifiers occur under a non-`move` default binding mode.
+    pub bad_ref_modifiers: bool,
     /// Whether any `&` or `&mut` patterns occur under a non-`move` default binding mode.
     pub bad_ref_pats: bool,
     /// If `true`, we can give a simpler suggestion solely by eliding explicit binding modifiers.

compiler/rustc_mir_build/messages.ftl

@@ -322,17 +322,6 @@ mir_build_pointer_pattern = function pointers and raw pointers not derived from
 
 mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future
 
-mir_build_rust_2024_incompatible_pat = {$bad_modifiers ->
-        *[true] binding modifiers{$bad_ref_pats ->
-            *[true] {" "}and reference patterns
-            [false] {""}
-        }
-        [false] reference patterns
-    } may only be written when the default binding mode is `move`{$is_hard_error ->
-        *[true] {""}
-        [false] {" "}in Rust 2024
-    }
-
 mir_build_static_in_pattern = statics cannot be referenced in patterns
     .label = can't be used in patterns
 mir_build_static_in_pattern_def = `static` defined here

compiler/rustc_mir_build/src/errors.rs

@@ -1,8 +1,7 @@
-use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
-    MultiSpan, Subdiagnostic, pluralize,
+    MultiSpan, Subdiagnostic,
 };
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
 use rustc_middle::ty::{self, Ty};
@@ -1087,69 +1086,6 @@ pub(crate) enum MiscPatternSuggestion {
     },
 }
 
-#[derive(LintDiagnostic)]
-#[diag(mir_build_rust_2024_incompatible_pat)]
-pub(crate) struct Rust2024IncompatiblePat {
-    #[subdiagnostic]
-    pub(crate) sugg: Rust2024IncompatiblePatSugg,
-    pub(crate) bad_modifiers: bool,
-    pub(crate) bad_ref_pats: bool,
-    pub(crate) is_hard_error: bool,
-}
-
-pub(crate) struct Rust2024IncompatiblePatSugg {
-    /// If true, our suggestion is to elide explicit binding modifiers.
-    /// If false, our suggestion is to make the pattern fully explicit.
-    pub(crate) suggest_eliding_modes: bool,
-    pub(crate) suggestion: Vec<(Span, String)>,
-    pub(crate) ref_pattern_count: usize,
-    pub(crate) binding_mode_count: usize,
-    /// Labels for where incompatibility-causing by-ref default binding modes were introduced.
-    pub(crate) default_mode_labels: FxIndexMap<Span, ty::Mutability>,
-}
-
-impl Subdiagnostic for Rust2024IncompatiblePatSugg {
-    fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
-        // Format and emit explanatory notes about default binding modes. Reversing the spans' order
-        // means if we have nested spans, the innermost ones will be visited first.
-        for (span, def_br_mutbl) in self.default_mode_labels.into_iter().rev() {
-            // Don't point to a macro call site.
-            if !span.from_expansion() {
-                let note_msg = "matching on a reference type with a non-reference pattern changes the default binding mode";
-                let label_msg =
-                    format!("this matches on type `{}_`", def_br_mutbl.ref_prefix_str());
-                let mut label = MultiSpan::from(span);
-                label.push_span_label(span, label_msg);
-                diag.span_note(label, note_msg);
-            }
-        }
-
-        // Format and emit the suggestion.
-        let applicability =
-            if self.suggestion.iter().all(|(span, _)| span.can_be_used_for_suggestions()) {
-                Applicability::MachineApplicable
-            } else {
-                Applicability::MaybeIncorrect
-            };
-        let msg = if self.suggest_eliding_modes {
-            let plural_modes = pluralize!(self.binding_mode_count);
-            format!("remove the unnecessary binding modifier{plural_modes}")
-        } else {
-            let plural_derefs = pluralize!(self.ref_pattern_count);
-            let and_modes = if self.binding_mode_count > 0 {
-                format!(" and variable binding mode{}", pluralize!(self.binding_mode_count))
-            } else {
-                String::new()
-            };
-            format!("make the implied reference pattern{plural_derefs}{and_modes} explicit")
-        };
-        // FIXME(dianne): for peace of mind, don't risk emitting a 0-part suggestion (that panics!)
-        if !self.suggestion.is_empty() {
-            diag.multipart_suggestion_verbose(msg, self.suggestion, applicability);
-        }
-    }
-}
-
 #[derive(Diagnostic)]
 #[diag(mir_build_loop_match_invalid_update)]
 pub(crate) struct LoopMatchInvalidUpdate {