Rollup of 7 pull requests

compiler/rustc_ast_lowering/messages.ftl

@@ -167,11 +167,23 @@ ast_lowering_template_modifier = template modifier
 
 ast_lowering_this_not_async = this is not `async`
 
+ast_lowering_underscore_array_length_unstable =
+ using `_` for array lengths is unstable
+
 ast_lowering_underscore_expr_lhs_assign =
  in expressions, `_` can only be used on the left-hand side of an assignment
  .label = `_` not allowed here
 
+ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture
+ast_lowering_unstable_inline_assembly_const_operands =
+ const operands for inline assembly are unstable
+ast_lowering_unstable_inline_assembly_label_operands =
+ label operands for inline assembly are unstable
+ast_lowering_unstable_may_unwind = the `may_unwind` option is unstable
+
 ast_lowering_use_angle_brackets = use angle brackets instead
+
+ast_lowering_yield = yield syntax is experimental
 ast_lowering_yield_in_closure =
  `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
  .suggestion = use `#[coroutine]` to make this closure a coroutine

compiler/rustc_ast_lowering/src/asm.rs

@@ -19,10 +19,12 @@ use super::errors::{
  InvalidRegisterClass, RegisterClassOnlyClobber, RegisterConflict,
 };
 use super::LoweringContext;
-use crate::{ImplTraitContext, ImplTraitPosition, ParamMode, ResolverAstLoweringExt};
+use crate::{
+ fluent_generated as fluent, ImplTraitContext, ImplTraitPosition, ParamMode,
+ ResolverAstLoweringExt,
+};
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  pub(crate) fn lower_inline_asm(
  &mut self,
  sp: Span,
@@ -52,7 +54,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  &self.tcx.sess,
  sym::asm_experimental_arch,
  sp,
- "inline assembly is not stable yet on this architecture",
+ fluent::ast_lowering_unstable_inline_assembly,
  )
  .emit();
  }
@@ -64,8 +66,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  self.dcx().emit_err(AttSyntaxOnlyX86 { span: sp });
  }
  if asm.options.contains(InlineAsmOptions::MAY_UNWIND) && !self.tcx.features().asm_unwind {
- feature_err(&self.tcx.sess, sym::asm_unwind, sp, "the `may_unwind` option is unstable")
- .emit();
+ feature_err(
+ &self.tcx.sess,
+ sym::asm_unwind,
+ sp,
+ fluent::ast_lowering_unstable_may_unwind,
+ )
+ .emit();
  }
 
  let mut clobber_abis = FxIndexMap::default();
@@ -182,7 +189,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  sess,
  sym::asm_const,
  *op_sp,
- "const operands for inline assembly are unstable",
+ fluent::ast_lowering_unstable_inline_assembly_const_operands,
  )
  .emit();
  }
@@ -246,7 +253,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  sess,
  sym::asm_goto,
  *op_sp,
- "label operands for inline assembly are unstable",
+ fluent::ast_lowering_unstable_inline_assembly_label_operands,
  )
  .emit();
  }

compiler/rustc_ast_lowering/src/expr.rs

@@ -23,7 +23,7 @@ use super::{
  ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs, ResolverAstLoweringExt,
 };
 use crate::errors::YieldInClosure;
-use crate::{FnDeclKind, ImplTraitPosition};
+use crate::{fluent_generated, FnDeclKind, ImplTraitPosition};
 
 impl<'hir> LoweringContext<'_, 'hir> {
  fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [hir::Expr<'hir>] {
@@ -1540,7 +1540,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
  }
  }
 
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  fn lower_expr_yield(&mut self, span: Span, opt_expr: Option<&Expr>) -> hir::ExprKind<'hir> {
  let yielded =
  opt_expr.as_ref().map(|x| self.lower_expr(x)).unwrap_or_else(|| self.expr_unit(span));
@@ -1575,7 +1574,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  &self.tcx.sess,
  sym::coroutines,
  span,
- "yield syntax is experimental",
+ fluent_generated::ast_lowering_yield,
  )
  .emit();
  }
@@ -1587,7 +1586,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
  &self.tcx.sess,
  sym::coroutines,
  span,
- "yield syntax is experimental",
+ fluent_generated::ast_lowering_yield,
  )
  .emit();
  }

compiler/rustc_ast_lowering/src/lib.rs

@@ -2326,7 +2326,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  self.expr_block(block)
  }
 
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  fn lower_array_length(&mut self, c: &AnonConst) -> hir::ArrayLen<'hir> {
  match c.value.kind {
  ExprKind::Underscore => {
@@ -2340,7 +2339,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  &self.tcx.sess,
  sym::generic_arg_infer,
  c.value.span,
- "using `_` for array lengths is unstable",
+ fluent_generated::ast_lowering_underscore_array_length_unstable,
  )
  .stash(c.value.span, StashKey::UnderscoreForArrayLengths);
  hir::ArrayLen::Body(self.lower_anon_const_to_const_arg(c))

compiler/rustc_attr/messages.ftl

@@ -104,6 +104,9 @@ attr_unknown_meta_item =
 attr_unknown_version_literal =
  unknown version literal format, assuming it refers to a future version
 
+attr_unstable_cfg_target_compact =
+ compact `cfg(target(..))` is experimental and subject to change
+
 attr_unsupported_literal_cfg_string =
  literal in `cfg` predicate value must be a string
 attr_unsupported_literal_deprecated_kv_pair =

compiler/rustc_attr/src/builtin.rs

@@ -20,6 +20,7 @@ use rustc_span::hygiene::Transparency;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 
+use crate::fluent_generated;
 use crate::session_diagnostics::{self, IncorrectReprFormatGenericCause};
 
 /// The version placeholder that recently stabilized features contain inside the
@@ -521,7 +522,6 @@ pub struct Condition {
 }
 
 /// Tests if a cfg-pattern matches the cfg set
-#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
 pub fn cfg_matches(
  cfg: &ast::MetaItem,
  sess: &Session,
@@ -593,7 +593,6 @@ pub fn parse_version(s: Symbol) -> Option<RustcVersion> {
 
 /// Evaluate a cfg-like condition (with `any` and `all`), using `eval` to
 /// evaluate individual items.
-#[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
 pub fn eval_condition(
  cfg: &ast::MetaItem,
  sess: &Session,
@@ -680,7 +679,7 @@ pub fn eval_condition(
  sess,
  sym::cfg_target_compact,
  cfg.span,
- "compact `cfg(target(..))` is experimental and subject to change",
+ fluent_generated::attr_unstable_cfg_target_compact,
  )
  .emit();
  }

compiler/rustc_borrowck/messages.ftl

@@ -62,6 +62,9 @@ borrowck_could_not_normalize =
 borrowck_could_not_prove =
  could not prove `{$predicate}`
 
+borrowck_dereference_suggestion =
+ dereference the return value
+
 borrowck_func_take_self_moved_place =
  `{$func}` takes ownership of the receiver `self`, which moves {$place_name}
 
@@ -74,9 +77,24 @@ borrowck_higher_ranked_lifetime_error =
 borrowck_higher_ranked_subtype_error =
  higher-ranked subtype error
 
+borrowck_implicit_static =
+ this has an implicit `'static` lifetime requirement
+
+borrowck_implicit_static_introduced =
+ calling this method introduces the `impl`'s `'static` requirement
+
+borrowck_implicit_static_relax =
+ consider relaxing the implicit `'static` requirement
+
 borrowck_lifetime_constraints_error =
  lifetime may not live long enough
 
+borrowck_limitations_implies_static =
+ due to current limitations in the borrow checker, this implies a `'static` lifetime
+
+borrowck_move_closure_suggestion =
+ consider adding 'move' keyword before the nested closure
+
 borrowck_move_out_place_here =
  {$place} is moved here
 
@@ -163,6 +181,9 @@ borrowck_partial_var_move_by_use_in_coroutine =
  *[false] moved
  } due to use in coroutine
 
+borrowck_restrict_to_static =
+ consider restricting the type parameter to the `'static` lifetime
+
 borrowck_returned_async_block_escaped =
  returns an `async` block that contains a reference to a captured variable, which then escapes the closure body
 

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -3,6 +3,8 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
 
+use std::assert_matches::assert_matches;
+
 use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
 use rustc_hir::intravisit::Visitor;
@@ -116,7 +118,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
  // path_span must be `Some` as otherwise the if condition is true
  let path_span = path_span.unwrap();
  // path_span is only present in the case of closure capture
- assert!(matches!(later_use_kind, LaterUseKind::ClosureCapture));
+ assert_matches!(later_use_kind, LaterUseKind::ClosureCapture);
  if !borrow_span.is_some_and(|sp| sp.overlaps(var_or_use_span)) {
  let path_label = "used here by closure";
  let capture_kind_label = message;
@@ -147,7 +149,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
  // path_span must be `Some` as otherwise the if condition is true
  let path_span = path_span.unwrap();
  // path_span is only present in the case of closure capture
- assert!(matches!(later_use_kind, LaterUseKind::ClosureCapture));
+ assert_matches!(later_use_kind, LaterUseKind::ClosureCapture);
  if borrow_span.map(|sp| !sp.overlaps(var_or_use_span)).unwrap_or(true) {
  let path_label = "used here by closure";
  let capture_kind_label = message;

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -35,7 +35,7 @@ use crate::session_diagnostics::{
  LifetimeReturnCategoryErr, RequireStaticErr, VarHereDenote,
 };
 use crate::universal_regions::DefiningTy;
-use crate::{borrowck_errors, MirBorrowckCtxt};
+use crate::{borrowck_errors, fluent_generated as fluent, MirBorrowckCtxt};
 
 impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
  fn description(&self) -> &'static str {
@@ -198,7 +198,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  // from higher-ranked trait bounds (HRTB). Try to locate span of the trait
  // and the span which bounded to the trait for adding 'static lifetime suggestion
  #[allow(rustc::diagnostic_outside_of_impl)]
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  fn suggest_static_lifetime_for_gat_from_hrtb(
  &self,
  diag: &mut Diag<'_>,
@@ -251,23 +250,28 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  debug!(?hrtb_bounds);
 
  hrtb_bounds.iter().for_each(|bound| {
- let Trait(PolyTraitRef { trait_ref, span: trait_span, .. }, _) = bound else { return; };
- diag.span_note(
- *trait_span,
- "due to current limitations in the borrow checker, this implies a `'static` lifetime"
- );
- let Some(generics_fn) = hir.get_generics(self.body.source.def_id().expect_local()) else { return; };
- let Def(_, trait_res_defid) = trait_ref.path.res else { return; };
+ let Trait(PolyTraitRef { trait_ref, span: trait_span, .. }, _) = bound else {
+ return;
+ };
+ diag.span_note(*trait_span, fluent::borrowck_limitations_implies_static);
+ let Some(generics_fn) = hir.get_generics(self.body.source.def_id().expect_local())
+ else {
+ return;
+ };
+ let Def(_, trait_res_defid) = trait_ref.path.res else {
+ return;
+ };
  debug!(?generics_fn);
  generics_fn.predicates.iter().for_each(|predicate| {
- let BoundPredicate(
- WhereBoundPredicate {
- span: bounded_span,
- bounded_ty,
- bounds,
- ..
- }
- ) = predicate else { return; };
+ let BoundPredicate(WhereBoundPredicate {
+ span: bounded_span,
+ bounded_ty,
+ bounds,
+ ..
+ }) = predicate
+ else {
+ return;
+ };
  bounds.iter().for_each(|bd| {
  if let Trait(PolyTraitRef { trait_ref: tr_ref, .. }, _) = bd
  && let Def(_, res_defid) = tr_ref.path.res
@@ -277,16 +281,17 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  && generics_fn.params
  .iter()
  .rfind(|param| param.def_id.to_def_id() == defid)
- .is_some() {
- suggestions.push((bounded_span.shrink_to_hi(), " + 'static".to_string()));
- }
+ .is_some()
+ {
+ suggestions.push((bounded_span.shrink_to_hi(), " + 'static".to_string()));
+ }
  });
  });
  });
  if suggestions.len() > 0 {
  suggestions.dedup();
  diag.multipart_suggestion_verbose(
- "consider restricting the type parameter to the `'static` lifetime",
+ fluent::borrowck_restrict_to_static,
  suggestions,
  Applicability::MaybeIncorrect,
  );
@@ -976,7 +981,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  }
 
  #[allow(rustc::diagnostic_outside_of_impl)]
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  #[instrument(skip(self, err), level = "debug")]
  fn suggest_constrain_dyn_trait_in_impl(
  &self,
@@ -994,16 +998,12 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  debug!("trait spans found: {:?}", traits);
  for span in &traits {
  let mut multi_span: MultiSpan = vec![*span].into();
- multi_span
- .push_span_label(*span, "this has an implicit `'static` lifetime requirement");
- multi_span.push_span_label(
- ident.span,
- "calling this method introduces the `impl`'s `'static` requirement",
- );
+ multi_span.push_span_label(*span, fluent::borrowck_implicit_static);
+ multi_span.push_span_label(ident.span, fluent::borrowck_implicit_static_introduced);
  err.subdiagnostic(RequireStaticErr::UsedImpl { multi_span });
  err.span_suggestion_verbose(
  span.shrink_to_hi(),
- "consider relaxing the implicit `'static` requirement",
+ fluent::borrowck_implicit_static_relax,
  " + '_",
  Applicability::MaybeIncorrect,
  );
@@ -1045,7 +1045,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  }
 
  #[allow(rustc::diagnostic_outside_of_impl)]
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  /// When encountering a lifetime error caused by the return type of a closure, check the
  /// corresponding trait bound and see if dereferencing the closure return value would satisfy
  /// them. If so, we produce a structured suggestion.
@@ -1166,15 +1165,14 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  if ocx.select_all_or_error().is_empty() && count > 0 {
  diag.span_suggestion_verbose(
  tcx.hir().body(*body).value.peel_blocks().span.shrink_to_lo(),
- "dereference the return value",
+ fluent::borrowck_dereference_suggestion,
  "*".repeat(count),
  Applicability::MachineApplicable,
  );
  }
  }
 
  #[allow(rustc::diagnostic_outside_of_impl)]
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
  fn suggest_move_on_borrowing_closure(&self, diag: &mut Diag<'_>) {
  let map = self.infcx.tcx.hir();
  let body = map.body_owned_by(self.mir_def_id());
@@ -1213,7 +1211,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  if let Some(closure_span) = closure_span {
  diag.span_suggestion_verbose(
  closure_span,
- "consider adding 'move' keyword before the nested closure",
+ fluent::borrowck_move_closure_suggestion,
  "move ",
  Applicability::MaybeIncorrect,
  );