Rollup of 15 pull requests

Cargo.lock

@@ -3767,6 +3767,7 @@ dependencies = [
 name = "rustc_driver_impl"
 version = "0.0.0"
 dependencies = [
+ "anstyle",
  "ctrlc",
  "jiff",
  "libc",
@@ -3792,6 +3793,7 @@ dependencies = [
  "rustc_index",
  "rustc_infer",
  "rustc_interface",
+ "rustc_lexer",
  "rustc_lint",
  "rustc_log",
  "rustc_macros",

compiler/rustc_ast/src/token.rs

@@ -625,12 +625,12 @@ impl TokenKind {
 }
 
 impl Token {
-    pub fn new(kind: TokenKind, span: Span) -> Self {
+    pub const fn new(kind: TokenKind, span: Span) -> Self {
         Token { kind, span }
     }
 
     /// Some token that will be thrown away later.
-    pub fn dummy() -> Self {
+    pub const fn dummy() -> Self {
         Token::new(TokenKind::Question, DUMMY_SP)
     }
 

compiler/rustc_ast_lowering/src/stability.rs

@@ -29,7 +29,6 @@ pub(crate) fn extern_abi_enabled(
     })
 }
 
-#[allow(rustc::untranslatable_diagnostic)]
 pub(crate) fn gate_unstable_abi(sess: &Session, features: &Features, span: Span, abi: ExternAbi) {
     match extern_abi_enabled(features, span, abi) {
         Ok(_) => (),

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -13,15 +13,11 @@ use crate::errors;
 macro_rules! gate {
     ($visitor:expr, $feature:ident, $span:expr, $explain:expr) => {{
         if !$visitor.features.$feature() && !$span.allows_unstable(sym::$feature) {
-            #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
             feature_err(&$visitor.sess, sym::$feature, $span, $explain).emit();
         }
     }};
     ($visitor:expr, $feature:ident, $span:expr, $explain:expr, $help:expr) => {{
         if !$visitor.features.$feature() && !$span.allows_unstable(sym::$feature) {
-            // FIXME: make this translatable
-            #[allow(rustc::diagnostic_outside_of_impl)]
-            #[allow(rustc::untranslatable_diagnostic)]
             feature_err(&$visitor.sess, sym::$feature, $span, $explain).with_help($help).emit();
         }
     }};
@@ -31,13 +27,11 @@ macro_rules! gate {
 macro_rules! gate_alt {
     ($visitor:expr, $has_feature:expr, $name:expr, $span:expr, $explain:expr) => {{
         if !$has_feature && !$span.allows_unstable($name) {
-            #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
             feature_err(&$visitor.sess, $name, $span, $explain).emit();
         }
     }};
     ($visitor:expr, $has_feature:expr, $name:expr, $span:expr, $explain:expr, $notes: expr) => {{
         if !$has_feature && !$span.allows_unstable($name) {
-            #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
             let mut diag = feature_err(&$visitor.sess, $name, $span, $explain);
             for note in $notes {
                 diag.note(*note);
@@ -491,7 +485,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
                 && (!visitor.features.gen_blocks() && !span.allows_unstable(sym::gen_blocks))
                 && (!visitor.features.yield_expr() && !span.allows_unstable(sym::yield_expr))
             {
-                #[allow(rustc::untranslatable_diagnostic)]
                 // Emit yield_expr as the error, since that will be sufficient. You can think of it
                 // as coroutines and gen_blocks imply yield_expr.
                 feature_err(&visitor.sess, sym::yield_expr, *span, "yield syntax is experimental")
@@ -523,7 +516,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
             if !visitor.features.min_generic_const_args()
                 && !span.allows_unstable(sym::min_generic_const_args)
             {
-                #[allow(rustc::untranslatable_diagnostic)]
                 feature_err(
                     &visitor.sess,
                     sym::min_generic_const_args,
@@ -559,7 +551,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
                 if let Ok(snippet) = sm.span_to_snippet(span)
                     && snippet == "!"
                 {
-                    #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
                     feature_err(sess, sym::never_patterns, span, "`!` patterns are experimental")
                         .emit();
                 } else {

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -412,7 +412,6 @@ fn try_gate_cfg(name: Symbol, span: Span, sess: &Session, features: Option<&Feat
     }
 }
 
-#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
 fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Features) {
     let (cfg, feature, has_feature) = gated_cfg;
     if !has_feature(features) && !cfg_span.allows_unstable(*feature) {

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -141,8 +141,6 @@ impl<S: Stage> CombineAttributeParser<S> for LinkParser {
 
                 macro report_unstable_modifier($feature: ident) {
                     if !features.$feature() {
-                        // FIXME: make this translatable
-                        #[expect(rustc::untranslatable_diagnostic)]
                         feature_err(
                             sess,
                             sym::$feature,

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -164,21 +164,6 @@ impl<S: Stage> SingleAttributeParser<S> for RustcLegacyConstGenericsParser {
     }
 }
 
-pub(crate) struct RustcLintDiagnosticsParser;
-
-impl<S: Stage> NoArgsAttributeParser<S> for RustcLintDiagnosticsParser {
-    const PATH: &[Symbol] = &[sym::rustc_lint_diagnostics];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
-        Allow(Target::Fn),
-        Allow(Target::Method(MethodKind::Inherent)),
-        Allow(Target::Method(MethodKind::Trait { body: false })),
-        Allow(Target::Method(MethodKind::Trait { body: true })),
-        Allow(Target::Method(MethodKind::TraitImpl)),
-    ]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintDiagnostics;
-}
-
 pub(crate) struct RustcLintOptDenyFieldAccessParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcLintOptDenyFieldAccessParser {

compiler/rustc_attr_parsing/src/attributes/transparency.rs

@@ -4,9 +4,6 @@ use super::prelude::*;
 
 pub(crate) struct TransparencyParser;
 
-// FIXME(jdonszelmann): make these proper diagnostics
-#[allow(rustc::untranslatable_diagnostic)]
-#[allow(rustc::diagnostic_outside_of_impl)]
 impl<S: Stage> SingleAttributeParser<S> for TransparencyParser {
     const PATH: &[Symbol] = &[sym::rustc_macro_transparency];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;

compiler/rustc_attr_parsing/src/context.rs

@@ -75,11 +75,11 @@ use crate::attributes::rustc_dump::{
 use crate::attributes::rustc_internal::{
     RustcHasIncoherentInherentImplsParser, RustcLayoutScalarValidRangeEndParser,
     RustcLayoutScalarValidRangeStartParser, RustcLegacyConstGenericsParser,
-    RustcLintDiagnosticsParser, RustcLintOptDenyFieldAccessParser, RustcLintOptTyParser,
-    RustcLintQueryInstabilityParser, RustcLintUntrackedQueryInformationParser, RustcMainParser,
-    RustcMustImplementOneOfParser, RustcNeverReturnsNullPointerParser,
-    RustcNoImplicitAutorefsParser, RustcNounwindParser, RustcObjectLifetimeDefaultParser,
-    RustcOffloadKernelParser, RustcScalableVectorParser, RustcSimdMonomorphizeLaneLimitParser,
+    RustcLintOptDenyFieldAccessParser, RustcLintOptTyParser, RustcLintQueryInstabilityParser,
+    RustcLintUntrackedQueryInformationParser, RustcMainParser, RustcMustImplementOneOfParser,
+    RustcNeverReturnsNullPointerParser, RustcNoImplicitAutorefsParser, RustcNounwindParser,
+    RustcObjectLifetimeDefaultParser, RustcOffloadKernelParser, RustcScalableVectorParser,
+    RustcSimdMonomorphizeLaneLimitParser,
 };
 use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
@@ -289,7 +289,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcDumpUserArgs>>,
         Single<WithoutArgs<RustcDumpVtable>>,
         Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
-        Single<WithoutArgs<RustcLintDiagnosticsParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,
         Single<WithoutArgs<RustcLintQueryInstabilityParser>>,
         Single<WithoutArgs<RustcLintUntrackedQueryInformationParser>>,

compiler/rustc_borrowck/src/borrow_set.rs

@@ -253,19 +253,52 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
             }
 
             let region = region.as_var();
-
-            let borrow = BorrowData {
+            let borrow = |activation_location| BorrowData {
                 kind,
                 region,
                 reserve_location: location,
-                activation_location: TwoPhaseActivation::NotTwoPhase,
+                activation_location,
                 borrowed_place,
                 assigned_place: *assigned_place,
             };
-            let (idx, _) = self.location_map.insert_full(location, borrow);
-            let idx = BorrowIndex::from(idx);
 
-            self.insert_as_pending_if_two_phase(location, assigned_place, kind, idx);
+            let idx = if !kind.is_two_phase_borrow() {
+                debug!("  -> {:?}", location);
+                let (idx, _) = self
+                    .location_map
+                    .insert_full(location, borrow(TwoPhaseActivation::NotTwoPhase));
+                BorrowIndex::from(idx)
+            } else {
+                // When we encounter a 2-phase borrow statement, it will always
+                // be assigning into a temporary TEMP:
+                //
+                //    TEMP = &foo
+                //
+                // so extract `temp`.
+                let Some(temp) = assigned_place.as_local() else {
+                    span_bug!(
+                        self.body.source_info(location).span,
+                        "expected 2-phase borrow to assign to a local, not `{:?}`",
+                        assigned_place,
+                    );
+                };
+
+                // Consider the borrow not activated to start. When we find an activation, we'll update
+                // this field.
+                let (idx, _) = self
+                    .location_map
+                    .insert_full(location, borrow(TwoPhaseActivation::NotActivated));
+                let idx = BorrowIndex::from(idx);
+
+                // Insert `temp` into the list of pending activations. From
+                // now on, we'll be on the lookout for a use of it. Note that
+                // we are guaranteed that this use will come after the
+                // assignment.
+                let prev = self.pending_activations.insert(temp, idx);
+                assert_eq!(prev, None, "temporary associated with multiple two phase borrows");
+
+                idx
+            };
 
             self.local_map.entry(borrowed_place.local).or_default().insert(idx);
         }
@@ -334,62 +367,3 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
         self.super_rvalue(rvalue, location)
     }
 }
-
-impl<'a, 'tcx> GatherBorrows<'a, 'tcx> {
-    /// If this is a two-phase borrow, then we will record it
-    /// as "pending" until we find the activating use.
-    fn insert_as_pending_if_two_phase(
-        &mut self,
-        start_location: Location,
-        assigned_place: &mir::Place<'tcx>,
-        kind: mir::BorrowKind,
-        borrow_index: BorrowIndex,
-    ) {
-        debug!(
-            "Borrows::insert_as_pending_if_two_phase({:?}, {:?}, {:?})",
-            start_location, assigned_place, borrow_index,
-        );
-
-        if !kind.allows_two_phase_borrow() {
-            debug!("  -> {:?}", start_location);
-            return;
-        }
-
-        // When we encounter a 2-phase borrow statement, it will always
-        // be assigning into a temporary TEMP:
-        //
-        //    TEMP = &foo
-        //
-        // so extract `temp`.
-        let Some(temp) = assigned_place.as_local() else {
-            span_bug!(
-                self.body.source_info(start_location).span,
-                "expected 2-phase borrow to assign to a local, not `{:?}`",
-                assigned_place,
-            );
-        };
-
-        // Consider the borrow not activated to start. When we find an activation, we'll update
-        // this field.
-        {
-            let borrow_data = &mut self.location_map[borrow_index.as_usize()];
-            borrow_data.activation_location = TwoPhaseActivation::NotActivated;
-        }
-
-        // Insert `temp` into the list of pending activations. From
-        // now on, we'll be on the lookout for a use of it. Note that
-        // we are guaranteed that this use will come after the
-        // assignment.
-        let old_value = self.pending_activations.insert(temp, borrow_index);
-        if let Some(old_index) = old_value {
-            span_bug!(
-                self.body.source_info(start_location).span,
-                "found already pending activation for temp: {:?} \
-                       at borrow_index: {:?} with associated data {:?}",
-                temp,
-                old_index,
-                self.location_map[old_index.as_usize()]
-            );
-        }
-    }
-}

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -1,6 +1,3 @@
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, DiagCtxtHandle, struct_span_code_err};
 use rustc_hir as hir;

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1,8 +1,5 @@
 // ignore-tidy-filelength
 
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use std::iter;
 use std::ops::ControlFlow;
 

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -1,8 +1,5 @@
 //! Print diagnostics to explain why values are borrowed.
 
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use rustc_data_structures::assert_matches;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee};
 use rustc_hir as hir;

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -162,8 +162,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         }
         for (_, (mut diag, count)) in std::mem::take(&mut self.diags_buffer.buffered_mut_errors) {
             if count > 10 {
-                #[allow(rustc::diagnostic_outside_of_impl)]
-                #[allow(rustc::untranslatable_diagnostic)]
                 diag.note(format!("...and {} other attempted mutable borrows", count - 10));
             }
             self.buffer_error(diag);
@@ -236,7 +234,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     /// LL |         for (key, value) in dict {
     ///    |                             ^^^^
     /// ```
-    #[allow(rustc::diagnostic_outside_of_impl)] // FIXME
     pub(super) fn add_moved_or_invoked_closure_note(
         &self,
         location: Location,
@@ -820,7 +817,6 @@ impl UseSpans<'_> {
     }
 
     /// Add a span label to the arguments of the closure, if it exists.
-    #[allow(rustc::diagnostic_outside_of_impl)]
     pub(super) fn args_subdiag(self, err: &mut Diag<'_>, f: impl FnOnce(Span) -> CaptureArgLabel) {
         if let UseSpans::ClosureUse { args_span, .. } = self {
             err.subdiagnostic(f(args_span));
@@ -829,7 +825,6 @@ impl UseSpans<'_> {
 
     /// Add a span label to the use of the captured variable, if it exists.
     /// only adds label to the `path_span`
-    #[allow(rustc::diagnostic_outside_of_impl)]
     pub(super) fn var_path_only_subdiag(
         self,
         err: &mut Diag<'_>,
@@ -861,7 +856,6 @@ impl UseSpans<'_> {
     }
 
     /// Add a subdiagnostic to the use of the captured variable, if it exists.
-    #[allow(rustc::diagnostic_outside_of_impl)]
     pub(super) fn var_subdiag(
         self,
         err: &mut Diag<'_>,
@@ -1225,8 +1219,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         self.borrow_spans(span, borrow.reserve_location)
     }
 
-    #[allow(rustc::diagnostic_outside_of_impl)]
-    #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
     fn explain_captures(
         &mut self,
         err: &mut Diag<'infcx>,

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -1,6 +1,3 @@
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::Visitor;

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1,6 +1,3 @@
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use core::ops::ControlFlow;
 
 use either::Either;

compiler/rustc_borrowck/src/diagnostics/opaque_types.rs

@@ -1,6 +1,3 @@
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use std::ops::ControlFlow;
 
 use either::Either;

compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs

@@ -1,9 +1,6 @@
 //! Contains utilities for generating suggestions for borrowck errors related to unsatisfied
 //! outlives constraints.
 
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
-
 use std::collections::BTreeMap;
 
 use rustc_data_structures::fx::FxIndexSet;