Auto merge of #157487 - CrooseGit:dev/reucru01/only, r=<try>

bors · bors · commit ea16527ccc0f · 2026-06-05T14:56:09.000Z
crater: reserve `only` keyword
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -3181,6 +3181,8 @@ pub enum BoundPolarity {
     Negative(Span),
     /// `Type: ?Trait`
     Maybe(Span),
+    /// `Type: only Trait`,
+    Only(Span),
 }
 
 impl BoundPolarity {
@@ -3189,6 +3191,7 @@ impl BoundPolarity {
             Self::Positive => "",
             Self::Negative(_) => "!",
             Self::Maybe(_) => "?",
+            Self::Only(_) => "only",
         }
     }
 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2773,6 +2773,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             BoundPolarity::Positive => BoundPolarity::Positive,
             BoundPolarity::Negative(span) => BoundPolarity::Negative(self.lower_span(span)),
             BoundPolarity::Maybe(span) => BoundPolarity::Maybe(self.lower_span(span)),
+            BoundPolarity::Only(span) => BoundPolarity::Only(self.lower_span(span)),
         };
         hir::TraitBoundModifiers { constness, polarity }
     }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1478,7 +1478,9 @@ impl<'a> State<'a> {
         }
         match polarity {
             ast::BoundPolarity::Positive => {}
-            ast::BoundPolarity::Negative(_) | ast::BoundPolarity::Maybe(_) => {
+            ast::BoundPolarity::Negative(_)
+            | ast::BoundPolarity::Maybe(_)
+            | ast::BoundPolarity::Only(_) => {
                 self.word(polarity.as_str());
             }
         }
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -331,7 +331,7 @@ pub(crate) struct EmptyConfusables {
 }
 
 #[derive(Diagnostic)]
-#[help("`#[{$name}{$attribute_args}]` can {$only}be applied to {$applied}")]
+#[help("`#[{$name}{$attribute_args}]` can {$only_prefix}be applied to {$applied}")]
 #[diag("`#[{$name}{$attribute_args}]` attribute cannot be used on {$target}")]
 pub(crate) struct InvalidTarget {
     #[primary_span]
@@ -345,7 +345,7 @@ pub(crate) struct InvalidTarget {
     pub name: AttrPath,
     pub target: &'static str,
     pub applied: DiagArgValue,
-    pub only: &'static str,
+    pub only_prefix: &'static str,
     pub attribute_args: &'static str,
     #[subdiagnostic]
     pub help: Option<InvalidTargetHelp>,
diff --git a/compiler/rustc_attr_parsing/src/target_checking.rs b/compiler/rustc_attr_parsing/src/target_checking.rs
@@ -128,12 +128,13 @@ impl<'sess> AttributeParser<'sess> {
         }
 
         let allowed_targets = allowed_targets.allowed_targets();
-        let (applied, only) = allowed_targets_applied(allowed_targets, cx.target, cx.features);
+        let (applied, only_prefix) =
+            allowed_targets_applied(allowed_targets, cx.target, cx.features);
         let diag = InvalidTarget {
             span: cx.attr_span.clone(),
             name: cx.attr_path.clone(),
             target: cx.target.plural_name(),
-            only: if only { "only " } else { "" },
+            only_prefix: if only_prefix { "only " } else { "" },
             applied: DiagArgValue::StrListSepByAnd(applied.into_iter().map(Cow::Owned).collect()),
             attribute_args,
             help: Self::target_checking_help(attribute_args, cx),
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -1430,7 +1430,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 span.push_span_label(expr.span, "you could clone this value");
                 let types: Vec<_> = types.into_iter().collect();
                 let msg = match &types[..] {
-                    [only] => format!("`{only}`"),
+                    [single] => format!("`{single}`"),
                     [head @ .., last] => format!(
                         "{} and `{last}`",
                         head.iter().map(|t| format!("`{t}`")).collect::<Vec<_>>().join(", ")
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -31,6 +31,8 @@ struct CollectedBound {
     maybe: bool,
     /// `!Trait`
     negative: bool,
+    /// `only Trait`
+    only_modifier: bool,
 }
 
 impl CollectedBound {
@@ -112,6 +114,7 @@ fn collect_bounds<'a, 'tcx>(
         match ptr.modifiers.polarity {
             hir::BoundPolarity::Maybe(_) => collect_into.maybe = true,
             hir::BoundPolarity::Negative(_) => collect_into.negative = true,
+            hir::BoundPolarity::Only(_) => collect_into.only_modifier = true,
             hir::BoundPolarity::Positive => collect_into.positive = true,
         }
     });
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -986,13 +986,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 self.require_bound_to_relax_default_trait(trait_ref, span);
                 true
             }
+            hir::BoundPolarity::Only(_) => true,
         };
         let bounds = if transient { &mut Vec::new() } else { bounds };
 
         let polarity = match polarity {
-            hir::BoundPolarity::Positive | hir::BoundPolarity::Maybe(_) => {
-                ty::PredicatePolarity::Positive
-            }
+            hir::BoundPolarity::Positive
+            | hir::BoundPolarity::Maybe(_)
+            | hir::BoundPolarity::Only(_) => ty::PredicatePolarity::Positive,
             hir::BoundPolarity::Negative(_) => ty::PredicatePolarity::Negative,
         };
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -824,6 +824,7 @@ impl<'a> State<'a> {
             hir::BoundPolarity::Positive => {}
             hir::BoundPolarity::Negative(_) => self.word("!"),
             hir::BoundPolarity::Maybe(_) => self.word("?"),
+            hir::BoundPolarity::Only(_) => self.word_space("only"),
         }
         self.print_formal_generic_params(t.bound_generic_params);
         self.print_trait_ref(&t.trait_ref);
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1152,7 +1152,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             has_ref_dupes && missing_trait_names.len() > 1 && matches!(rcvr_ty.kind(), ty::Adt(..));
         let missing_trait_list = if should_condense {
             Some(match missing_trait_names.as_slice() {
-                [only] => only.clone(),
+                [single] => single.clone(),
                 [first, second] => format!("{first} or {second}"),
                 [rest @ .., last] => format!("{} or {last}", rest.join(", ")),
                 [] => String::new(),
@@ -1493,13 +1493,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 inherent_impls_candidate.dedup();
                 let msg = match &inherent_impls_candidate[..] {
                     [] => return,
-                    [only] => {
+                    [single] => {
                         vec![
                             StringPart::normal(format!("the {item_kind} was found for `")),
                             StringPart::highlighted(
                                 self.tcx
                                     .at(span)
-                                    .type_of(*only)
+                                    .type_of(*single)
                                     .instantiate_identity()
                                     .skip_norm_wip()
                                     .to_string(),
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
@@ -41,7 +41,7 @@ macro_rules! pluralize {
 // FIXME(estebank): this needs to be changed to go through the translation machinery.
 pub fn listify<T>(list: &[T], fmt: impl Fn(&T) -> String) -> Option<String> {
     Some(match list {
-        [only] => fmt(&only),
+        [single] => fmt(&single),
         [others @ .., last] => format!(
             "{} and {}",
             others.iter().map(|i| fmt(i)).collect::<Vec<_>>().join(", "),
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -1373,29 +1373,29 @@ fn report_non_exhaustive_match<'p, 'tcx>(
                 format!(" {{{indentation}{more}{suggested_arm},{indentation}}}",),
             ));
         }
-        [only] => {
-            let only = &thir[*only];
+        [single] => {
+            let single = &thir[*single];
             let (pre_indentation, is_multiline) = if let Some(snippet) =
-                sm.indentation_before(only.span)
+                sm.indentation_before(single.span)
                 && let Ok(with_trailing) =
-                    sm.span_extend_while(only.span, |c| c.is_whitespace() || c == ',')
+                    sm.span_extend_while(single.span, |c| c.is_whitespace() || c == ',')
                 && sm.is_multiline(with_trailing)
             {
                 (format!("\n{snippet}"), true)
             } else {
                 (" ".to_string(), false)
             };
-            let only_body = &thir[only.body];
+            let only_body = &thir[single.body];
             let comma = if matches!(only_body.kind, ExprKind::Block { .. })
-                && only.span.eq_ctxt(only_body.span)
+                && single.span.eq_ctxt(only_body.span)
                 && is_multiline
             {
                 ""
             } else {
                 ","
             };
             suggestion = Some((
-                only.span.shrink_to_hi(),
+                single.span.shrink_to_hi(),
                 format!("{comma}{pre_indentation}{suggested_arm}"),
             ));
         }
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -828,7 +828,7 @@ impl<'a> Parser<'a> {
         });
         let attr_span = match &expr.attrs[..] {
             [] => unreachable!(),
-            [only] => only.span,
+            [single] => single.span,
             [first, rest @ ..] => {
                 for attr in rest {
                     err.span_label(attr.span, "");
diff --git a/compiler/rustc_parse/src/parser/token_type.rs b/compiler/rustc_parse/src/parser/token_type.rs
@@ -106,6 +106,7 @@ pub enum TokenType {
     KwMod,
     KwMove,
     KwMut,
+    KwOnly,
     KwPub,
     KwRaw,
     KwRef,
@@ -540,6 +541,7 @@ macro_rules! exp {
     (Mod)            => { exp!(@kw, Mod,        KwMod) };
     (Move)           => { exp!(@kw, Move,       KwMove) };
     (Mut)            => { exp!(@kw, Mut,        KwMut) };
+    (Only)           => { exp!(@kw, Only,       KwOnly) };
     (Pub)            => { exp!(@kw, Pub,        KwPub) };
     (Raw)            => { exp!(@kw, Raw,        KwRaw) };
     (Ref)            => { exp!(@kw, Ref,        KwRef) };
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
@@ -1120,6 +1120,7 @@ impl<'a> Parser<'a> {
             || self.check(exp!(OpenParen))
             || self.can_begin_maybe_const_bound()
             || self.check_keyword(exp!(Const))
+            || self.check_keyword(exp!(Only))
             || self.check_keyword(exp!(Async))
             || self.check_keyword(exp!(Use))
     }
@@ -1201,7 +1202,9 @@ impl<'a> Parser<'a> {
 
         match polarity {
             BoundPolarity::Positive => {}
-            BoundPolarity::Negative(span) | BoundPolarity::Maybe(span) => {
+            BoundPolarity::Negative(span)
+            | BoundPolarity::Maybe(span)
+            | BoundPolarity::Only(span) => {
                 return self
                     .dcx()
                     .emit_err(errors::ModifierLifetime { span, modifier: polarity.as_str() });
@@ -1265,6 +1268,8 @@ impl<'a> Parser<'a> {
         } else if self.eat(exp!(Bang)) {
             self.psess.gated_spans.gate(sym::negative_bounds, self.prev_token.span);
             BoundPolarity::Negative(self.prev_token.span)
+        } else if self.eat_keyword(exp!(Only)) {
+            BoundPolarity::Only(self.prev_token.span)
         } else {
             BoundPolarity::Positive
         };
@@ -1274,7 +1279,9 @@ impl<'a> Parser<'a> {
             BoundPolarity::Positive => {
                 // All trait bound modifiers allowed to combine with positive polarity
             }
-            BoundPolarity::Maybe(polarity_span) | BoundPolarity::Negative(polarity_span) => {
+            BoundPolarity::Maybe(polarity_span)
+            | BoundPolarity::Negative(polarity_span)
+            | BoundPolarity::Only(polarity_span) => {
                 match (asyncness, constness) {
                     (BoundAsyncness::Normal, BoundConstness::Never) => {
                         // Ok, no modifiers.
@@ -1346,7 +1353,9 @@ impl<'a> Parser<'a> {
 
         if let Some(binder_span) = binder_span {
             match modifiers.polarity {
-                BoundPolarity::Negative(polarity_span) | BoundPolarity::Maybe(polarity_span) => {
+                BoundPolarity::Negative(polarity_span)
+                | BoundPolarity::Maybe(polarity_span)
+                | BoundPolarity::Only(polarity_span) => {
                     self.dcx().emit_err(errors::BinderAndPolarity {
                         binder_span,
                         polarity_span,
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -61,6 +61,7 @@ symbols! {
         Mod:                "mod",
         Move:               "move",
         Mut:                "mut",
+        Only:               "only",
         Pub:                "pub",
         Ref:                "ref",
         Return:             "return",
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -267,6 +267,7 @@ pub(crate) fn print_generic_bound(
                 hir::BoundPolarity::Positive => "",
                 hir::BoundPolarity::Maybe(_) => "?",
                 hir::BoundPolarity::Negative(_) => "!",
+                hir::BoundPolarity::Only(_) => "only",
             })?;
             print_poly_trait(ty, cx).fmt(f)
         }
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
@@ -576,6 +576,7 @@ fn poly_trait_ref_search_pat(poly_trait_ref: &PolyTraitRef<'_>) -> (Pat, Pat) {
     .or_else(|| match polarity {
         BoundPolarity::Negative(_) => Some(Pat::Str("!")),
         BoundPolarity::Maybe(_) => Some(Pat::Str("?")),
+        BoundPolarity::Only(_) => Some(Pat::Str("only")),
         BoundPolarity::Positive => None,
     })
     .unwrap_or(trait_ref_search_pat.0);
diff --git a/src/tools/clippy/lintcheck/src/config.rs b/src/tools/clippy/lintcheck/src/config.rs
@@ -1,7 +1,8 @@
-use clap::{Parser, Subcommand, ValueEnum};
 use std::num::NonZero;
 use std::path::PathBuf;
 
+use clap::{Parser, Subcommand, ValueEnum};
+
 #[expect(clippy::struct_excessive_bools)]
 #[derive(Parser, Clone, Debug)]
 #[command(args_conflicts_with_subcommands = true)]
@@ -33,7 +34,7 @@ pub(crate) struct LintcheckConfig {
     pub lintcheck_results_path: PathBuf, // Overridden in new()
     /// Only process a single crate on the list
     #[clap(long, value_name = "CRATE")]
-    pub only: Option<String>,
+    pub only_crate: Option<String>,
     /// Runs cargo clippy --fix and checks if all suggestions apply
     #[clap(long, conflicts_with("max_jobs"))]
     pub fix: bool,
@@ -124,10 +125,7 @@ impl LintcheckConfig {
         for lint_name in &mut config.lint_filter {
             *lint_name = format!(
                 "clippy::{}",
-                lint_name
-                    .strip_prefix("clippy::")
-                    .unwrap_or(lint_name)
-                    .replace('_', "-")
+                lint_name.strip_prefix("clippy::").unwrap_or(lint_name).replace('_', "-")
             );
         }
 
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/analysis_stats.rs
@@ -836,7 +836,7 @@ impl flags::AnalysisStats {
             let name = body_id.name(db).unwrap_or_else(Name::missing);
             let module = body_id.module(db);
             let display_target = module.krate(db).to_display_target(db);
-            if let Some(only_name) = self.only.as_deref()
+            if let Some(only_name) = self.solely.as_deref()
                 && name.display(db, Edition::LATEST).to_string() != only_name
                 && full_name(db, || body_id.name(db), module) != only_name
             {
@@ -951,7 +951,7 @@ impl flags::AnalysisStats {
                     }
                     is_partially_unknown
                 };
-                if self.only.is_some() && verbosity.is_spammy() {
+                if self.solely.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single expression
                     if let Some((_, start, end)) = expr_syntax_range(db, vfs, sm(), expr_id) {
                         bar.println(format!(
@@ -1056,7 +1056,7 @@ impl flags::AnalysisStats {
                     }
                     is_partially_unknown
                 };
-                if self.only.is_some() && verbosity.is_spammy() {
+                if self.solely.is_some() && verbosity.is_spammy() {
                     // in super-verbose mode for just one function, we print every single pattern
                     if let Some((_, start, end)) = pat_syntax_range(db, vfs, sm(), pat_id) {
                         bar.println(format!(
@@ -1461,7 +1461,7 @@ impl flags::AnalysisStats {
         name_fn: impl Fn() -> Option<Name>,
         module: hir::Module,
     ) -> bool {
-        if let Some(only_name) = self.only.as_deref() {
+        if let Some(only_name) = self.solely.as_deref() {
             let name = name_fn().unwrap_or_else(Name::missing);
 
             if name.display(db, Edition::LATEST).to_string() != only_name
diff --git a/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs b/src/tools/rust-analyzer/crates/rust-analyzer/src/cli/flags.rs
@@ -256,7 +256,7 @@ pub struct AnalysisStats {
     pub output: Option<OutputFormat>,
     pub randomize: bool,
     pub parallel: bool,
-    pub only: Option<String>,
+    pub solely: Option<String>,
     pub with_deps: bool,
     pub no_sysroot: bool,
     pub no_test: bool,

Original file line number	Diff line number	Diff line change
`@@ -3181,6 +3181,8 @@ pub enum BoundPolarity {`
`3181`	`3181`	`Negative(Span),`
`3182`	`3182`	/// `Type: ?Trait`
`3183`	`3183`	`Maybe(Span),`
	`3184`	+ /// `Type: only Trait`,
	`3185`	`+ Only(Span),`
`3184`	`3186`	`}`
`3185`	`3187`
`3186`	`3188`	`impl BoundPolarity {`
`@@ -3189,6 +3191,7 @@ impl BoundPolarity {`
`3189`	`3191`	`Self::Positive => "",`
`3190`	`3192`	`Self::Negative(_) => "!",`
`3191`	`3193`	`Self::Maybe(_) => "?",`
	`3194`	`+ Self::Only(_) => "only",`
`3192`	`3195`	`}`
`3193`	`3196`	`}`
`3194`	`3197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2773,6 +2773,7 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`2773`	`2773`	`BoundPolarity::Positive => BoundPolarity::Positive,`
`2774`	`2774`	`BoundPolarity::Negative(span) => BoundPolarity::Negative(self.lower_span(span)),`
`2775`	`2775`	`BoundPolarity::Maybe(span) => BoundPolarity::Maybe(self.lower_span(span)),`
	`2776`	`+ BoundPolarity::Only(span) => BoundPolarity::Only(self.lower_span(span)),`
`2776`	`2777`	`};`
`2777`	`2778`	`hir::TraitBoundModifiers { constness, polarity }`
`2778`	`2779`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1478,7 +1478,9 @@ impl<'a> State<'a> {`
`1478`	`1478`	`}`
`1479`	`1479`	`match polarity {`
`1480`	`1480`	`ast::BoundPolarity::Positive => {}`
`1481`		`- ast::BoundPolarity::Negative(_) \| ast::BoundPolarity::Maybe(_) => {`
	`1481`	`+ ast::BoundPolarity::Negative(_)`
	`1482`	`+ \| ast::BoundPolarity::Maybe(_)`
	`1483`	`+ \| ast::BoundPolarity::Only(_) => {`
`1482`	`1484`	`self.word(polarity.as_str());`
`1483`	`1485`	`}`
`1484`	`1486`	`}`
Original file line number	Diff line number	Diff line change
`@@ -824,6 +824,7 @@ impl<'a> State<'a> {`
`824`	`824`	`hir::BoundPolarity::Positive => {}`
`825`	`825`	`hir::BoundPolarity::Negative(_) => self.word("!"),`
`826`	`826`	`hir::BoundPolarity::Maybe(_) => self.word("?"),`
	`827`	`+ hir::BoundPolarity::Only(_) => self.word_space("only"),`
`827`	`828`	`}`
`828`	`829`	`self.print_formal_generic_params(t.bound_generic_params);`
`829`	`830`	`self.print_trait_ref(&t.trait_ref);`