Remove existing instances of only

CrooseGit · CrooseGit · commit 04631461d8ab · 2026-06-05T15:21:04.000+01:00
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
@@ -124,12 +124,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_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/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,
