| #![allow(rustc::diagnostic_outside_of_impl)] |
| #![allow(rustc::untranslatable_diagnostic)] |
| |
| use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS; |
| use rustc_errors::{add_elided_lifetime_in_path_suggestion, Diag}; |
| use rustc_errors::{Applicability, SuggestionStyle}; |
| use rustc_middle::middle::stability; |
| use rustc_session::config::ExpectedValues; |
| use rustc_session::lint::BuiltinLintDiag; |
| use rustc_session::Session; |
| use rustc_span::edit_distance::find_best_match_for_name; |
| use rustc_span::symbol::{sym, Symbol}; |
| use rustc_span::BytePos; |
| |
| const MAX_CHECK_CFG_NAMES_OR_VALUES: usize = 35; |
| |
| fn check_cfg_expected_note( |
| sess: &Session, |
| possibilities: &[Symbol], |
| type_: &str, |
| name: Option<Symbol>, |
| suffix: &str, |
| ) -> String { |
| use std::fmt::Write; |
| |
| let n_possibilities = if sess.opts.unstable_opts.check_cfg_all_expected { |
| possibilities.len() |
| } else { |
| std::cmp::min(possibilities.len(), MAX_CHECK_CFG_NAMES_OR_VALUES) |
| }; |
| |
| let mut possibilities = possibilities.iter().map(Symbol::as_str).collect::<Vec<_>>(); |
| possibilities.sort(); |
| |
| let and_more = possibilities.len().saturating_sub(n_possibilities); |
| let possibilities = possibilities[..n_possibilities].join("`, `"); |
| |
| let mut note = String::with_capacity(50 + possibilities.len()); |
| |
| write!(&mut note, "expected {type_}").unwrap(); |
| if let Some(name) = name { |
| write!(&mut note, " for `{name}`").unwrap(); |
| } |
| write!(&mut note, " are: {suffix}`{possibilities}`").unwrap(); |
| if and_more > 0 { |
| write!(&mut note, " and {and_more} more").unwrap(); |
| } |
| |
| note |
| } |
| |
| pub(super) fn builtin(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Diag<'_, ()>) { |
| match diagnostic { |
| BuiltinLintDiag::UnicodeTextFlow(span, content) => { |
| let spans: Vec<_> = content |
| .char_indices() |
| .filter_map(|(i, c)| { |
| TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| { |
| let lo = span.lo() + BytePos(2 + i as u32); |
| (c, span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32))) |
| }) |
| }) |
| .collect(); |
| let (an, s) = match spans.len() { |
| 1 => ("an ", ""), |
| _ => ("", "s"), |
| }; |
| diag.span_label( |
| span, |
| format!( |
| "this comment contains {an}invisible unicode text flow control codepoint{s}", |
| ), |
| ); |
| for (c, span) in &spans { |
| diag.span_label(*span, format!("{c:?}")); |
| } |
| diag.note( |
| "these kind of unicode codepoints change the way text flows on \ |
| applications that support them, but can cause confusion because they \ |
| change the order of characters on the screen", |
| ); |
| if !spans.is_empty() { |
| diag.multipart_suggestion_with_style( |
| "if their presence wasn't intentional, you can remove them", |
| spans.into_iter().map(|(_, span)| (span, "".to_string())).collect(), |
| Applicability::MachineApplicable, |
| SuggestionStyle::HideCodeAlways, |
| ); |
| } |
| } |
| BuiltinLintDiag::Normal => (), |
| BuiltinLintDiag::AbsPathWithModule(span) => { |
| let (sugg, app) = match sess.source_map().span_to_snippet(span) { |
| Ok(ref s) => { |
| // FIXME(Manishearth) ideally the emitting code |
| // can tell us whether or not this is global |
| let opt_colon = if s.trim_start().starts_with("::") { "" } else { "::" }; |
| |
| (format!("crate{opt_colon}{s}"), Applicability::MachineApplicable) |
| } |
| Err(_) => ("crate::<path>".to_string(), Applicability::HasPlaceholders), |
| }; |
| diag.span_suggestion(span, "use `crate`", sugg, app); |
| } |
| BuiltinLintDiag::ProcMacroDeriveResolutionFallback(span) => { |
| diag.span_label( |
| span, |
| "names from parent modules are not accessible without an explicit import", |
| ); |
| } |
| BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => { |
| diag.span_note(span_def, "the macro is defined here"); |
| } |
| BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => { |
| add_elided_lifetime_in_path_suggestion( |
| sess.source_map(), |
| diag, |
| n, |
| path_span, |
| incl_angl_brckt, |
| insertion_span, |
| ); |
| } |
| BuiltinLintDiag::UnknownCrateTypes(span, note, sugg) => { |
| diag.span_suggestion(span, note, sugg, Applicability::MaybeIncorrect); |
| } |
| BuiltinLintDiag::UnusedImports(message, replaces, in_test_module) => { |
| if !replaces.is_empty() { |
| diag.tool_only_multipart_suggestion( |
| message, |
| replaces, |
| Applicability::MachineApplicable, |
| ); |
| } |
| |
| if let Some(span) = in_test_module { |
| diag.span_help( |
| sess.source_map().guess_head_span(span), |
| "if this is a test module, consider adding a `#[cfg(test)]` to the containing module", |
| ); |
| } |
| } |
| BuiltinLintDiag::RedundantImport(spans, ident) => { |
| for (span, is_imported) in spans { |
| let introduced = if is_imported { "imported" } else { "defined" }; |
| let span_msg = if span.is_dummy() { "by prelude" } else { "here" }; |
| diag.span_label( |
| span, |
| format!("the item `{ident}` is already {introduced} {span_msg}"), |
| ); |
| } |
| } |
| BuiltinLintDiag::DeprecatedMacro(suggestion, span) => { |
| stability::deprecation_suggestion(diag, "macro", suggestion, span) |
| } |
| BuiltinLintDiag::UnusedDocComment(span) => { |
| diag.span_label(span, "rustdoc does not generate documentation for macro invocations"); |
| diag.help("to document an item produced by a macro, \ |
| the macro must produce the documentation as part of its expansion"); |
| } |
| BuiltinLintDiag::PatternsInFnsWithoutBody(span, ident) => { |
| diag.span_suggestion( |
| span, |
| "remove `mut` from the parameter", |
| ident, |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::MissingAbi(span, default_abi) => { |
| diag.span_label(span, "ABI should be specified here"); |
| diag.help(format!("the default ABI is {}", default_abi.name())); |
| } |
| BuiltinLintDiag::LegacyDeriveHelpers(span) => { |
| diag.span_label(span, "the attribute is introduced here"); |
| } |
| BuiltinLintDiag::ProcMacroBackCompat(note) => { |
| diag.note(note); |
| } |
| BuiltinLintDiag::OrPatternsBackCompat(span, suggestion) => { |
| diag.span_suggestion( |
| span, |
| "use pat_param to preserve semantics", |
| suggestion, |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::ReservedPrefix(span) => { |
| diag.span_label(span, "unknown prefix"); |
| diag.span_suggestion_verbose( |
| span.shrink_to_hi(), |
| "insert whitespace here to avoid this being parsed as a prefix in Rust 2021", |
| " ", |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, macro_name, invoc_span } => { |
| diag.span_note( |
| invoc_span, |
| format!("the built-in attribute `{attr_name}` will be ignored, since it's applied to the macro invocation `{macro_name}`") |
| ); |
| } |
| BuiltinLintDiag::TrailingMacro(is_trailing, name) => { |
| if is_trailing { |
| diag.note("macro invocations at the end of a block are treated as expressions"); |
| diag.note(format!("to ignore the value produced by the macro, add a semicolon after the invocation of `{name}`")); |
| } |
| } |
| BuiltinLintDiag::BreakWithLabelAndLoop(span) => { |
| diag.multipart_suggestion( |
| "wrap this expression in parentheses", |
| vec![ |
| (span.shrink_to_lo(), "(".to_string()), |
| (span.shrink_to_hi(), ")".to_string()), |
| ], |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::NamedAsmLabel(help) => { |
| diag.help(help); |
| diag.note("see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information"); |
| } |
| BuiltinLintDiag::UnexpectedCfgName((name, name_span), value) => { |
| #[allow(rustc::potential_query_instability)] |
| let possibilities: Vec<Symbol> = |
| sess.psess.check_config.expecteds.keys().copied().collect(); |
| |
| let mut names_possibilities: Vec<_> = if value.is_none() { |
| // We later sort and display all the possibilities, so the order here does not matter. |
| #[allow(rustc::potential_query_instability)] |
| sess.psess |
| .check_config |
| .expecteds |
| .iter() |
| .filter_map(|(k, v)| match v { |
| ExpectedValues::Some(v) if v.contains(&Some(name)) => Some(k), |
| _ => None, |
| }) |
| .collect() |
| } else { |
| Vec::new() |
| }; |
| |
| let is_from_cargo = rustc_session::utils::was_invoked_from_cargo(); |
| let mut is_feature_cfg = name == sym::feature; |
| |
| if is_feature_cfg && is_from_cargo { |
| diag.help("consider defining some features in `Cargo.toml`"); |
| // Suggest the most probable if we found one |
| } else if let Some(best_match) = find_best_match_for_name(&possibilities, name, None) { |
| if let Some(ExpectedValues::Some(best_match_values)) = |
| sess.psess.check_config.expecteds.get(&best_match) |
| { |
| // We will soon sort, so the initial order does not matter. |
| #[allow(rustc::potential_query_instability)] |
| let mut possibilities = |
| best_match_values.iter().flatten().map(Symbol::as_str).collect::<Vec<_>>(); |
| possibilities.sort(); |
| |
| let mut should_print_possibilities = true; |
| if let Some((value, value_span)) = value { |
| if best_match_values.contains(&Some(value)) { |
| diag.span_suggestion( |
| name_span, |
| "there is a config with a similar name and value", |
| best_match, |
| Applicability::MaybeIncorrect, |
| ); |
| should_print_possibilities = false; |
| } else if best_match_values.contains(&None) { |
| diag.span_suggestion( |
| name_span.to(value_span), |
| "there is a config with a similar name and no value", |
| best_match, |
| Applicability::MaybeIncorrect, |
| ); |
| should_print_possibilities = false; |
| } else if let Some(first_value) = possibilities.first() { |
| diag.span_suggestion( |
| name_span.to(value_span), |
| "there is a config with a similar name and different values", |
| format!("{best_match} = \"{first_value}\""), |
| Applicability::MaybeIncorrect, |
| ); |
| } else { |
| diag.span_suggestion( |
| name_span.to(value_span), |
| "there is a config with a similar name and different values", |
| best_match, |
| Applicability::MaybeIncorrect, |
| ); |
| }; |
| } else { |
| diag.span_suggestion( |
| name_span, |
| "there is a config with a similar name", |
| best_match, |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| |
| if !possibilities.is_empty() && should_print_possibilities { |
| let possibilities = possibilities.join("`, `"); |
| diag.help(format!( |
| "expected values for `{best_match}` are: `{possibilities}`" |
| )); |
| } |
| } else { |
| diag.span_suggestion( |
| name_span, |
| "there is a config with a similar name", |
| best_match, |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| |
| is_feature_cfg |= best_match == sym::feature; |
| } else { |
| if !names_possibilities.is_empty() && names_possibilities.len() <= 3 { |
| names_possibilities.sort(); |
| for cfg_name in names_possibilities.iter() { |
| diag.span_suggestion( |
| name_span, |
| "found config with similar value", |
| format!("{cfg_name} = \"{name}\""), |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } |
| if !possibilities.is_empty() { |
| diag.help_once(check_cfg_expected_note( |
| sess, |
| &possibilities, |
| "names", |
| None, |
| "", |
| )); |
| } |
| } |
| |
| let inst = if let Some((value, _value_span)) = value { |
| let pre = if is_from_cargo { "\\" } else { "" }; |
| format!("cfg({name}, values({pre}\"{value}{pre}\"))") |
| } else { |
| format!("cfg({name})") |
| }; |
| |
| if is_from_cargo { |
| if !is_feature_cfg { |
| diag.help(format!("consider using a Cargo feature instead or adding `println!(\"cargo:rustc-check-cfg={inst}\");` to the top of a `build.rs`")); |
| } |
| diag.note("see <https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#check-cfg> for more information about checking conditional configuration"); |
| } else { |
| diag.help(format!("to expect this configuration use `--check-cfg={inst}`")); |
| diag.note("see <https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html> for more information about checking conditional configuration"); |
| } |
| } |
| BuiltinLintDiag::UnexpectedCfgValue((name, name_span), value) => { |
| let Some(ExpectedValues::Some(values)) = &sess.psess.check_config.expecteds.get(&name) |
| else { |
| bug!( |
| "it shouldn't be possible to have a diagnostic on a value whose name is not in values" |
| ); |
| }; |
| let mut have_none_possibility = false; |
| // We later sort possibilities if it is not empty, so the |
| // order here does not matter. |
| #[allow(rustc::potential_query_instability)] |
| let possibilities: Vec<Symbol> = values |
| .iter() |
| .inspect(|a| have_none_possibility |= a.is_none()) |
| .copied() |
| .flatten() |
| .collect(); |
| let is_from_cargo = rustc_session::utils::was_invoked_from_cargo(); |
| |
| // Show the full list if all possible values for a given name, but don't do it |
| // for names as the possibilities could be very long |
| if !possibilities.is_empty() { |
| diag.note(check_cfg_expected_note( |
| sess, |
| &possibilities, |
| "values", |
| Some(name), |
| if have_none_possibility { "(none), " } else { "" }, |
| )); |
| |
| if let Some((value, value_span)) = value { |
| // Suggest the most probable if we found one |
| if let Some(best_match) = find_best_match_for_name(&possibilities, value, None) |
| { |
| diag.span_suggestion( |
| value_span, |
| "there is a expected value with a similar name", |
| format!("\"{best_match}\""), |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } else if let &[first_possibility] = &possibilities[..] { |
| diag.span_suggestion( |
| name_span.shrink_to_hi(), |
| "specify a config value", |
| format!(" = \"{first_possibility}\""), |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } else if have_none_possibility { |
| diag.note(format!("no expected value for `{name}`")); |
| if let Some((_value, value_span)) = value { |
| diag.span_suggestion( |
| name_span.shrink_to_hi().to(value_span), |
| "remove the value", |
| "", |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } else { |
| diag.note(format!("no expected values for `{name}`")); |
| |
| let sp = if let Some((_value, value_span)) = value { |
| name_span.to(value_span) |
| } else { |
| name_span |
| }; |
| diag.span_suggestion(sp, "remove the condition", "", Applicability::MaybeIncorrect); |
| } |
| |
| // We don't want to suggest adding values to well known names |
| // since those are defined by rustc it-self. Users can still |
| // do it if they want, but should not encourage them. |
| let is_cfg_a_well_know_name = sess.psess.check_config.well_known_names.contains(&name); |
| |
| let inst = if let Some((value, _value_span)) = value { |
| let pre = if is_from_cargo { "\\" } else { "" }; |
| format!("cfg({name}, values({pre}\"{value}{pre}\"))") |
| } else { |
| format!("cfg({name})") |
| }; |
| |
| if is_from_cargo { |
| if name == sym::feature { |
| if let Some((value, _value_span)) = value { |
| diag.help(format!( |
| "consider adding `{value}` as a feature in `Cargo.toml`" |
| )); |
| } else { |
| diag.help("consider defining some features in `Cargo.toml`"); |
| } |
| } else if !is_cfg_a_well_know_name { |
| diag.help(format!("consider using a Cargo feature instead or adding `println!(\"cargo:rustc-check-cfg={inst}\");` to the top of a `build.rs`")); |
| } |
| diag.note("see <https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#check-cfg> for more information about checking conditional configuration"); |
| } else { |
| if !is_cfg_a_well_know_name { |
| diag.help(format!("to expect this configuration use `--check-cfg={inst}`")); |
| } |
| diag.note("see <https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html> for more information about checking conditional configuration"); |
| } |
| } |
| BuiltinLintDiag::DeprecatedWhereclauseLocation(sugg) => { |
| let left_sp = diag.span.primary_span().unwrap(); |
| match sugg { |
| Some((right_sp, sugg)) => diag.multipart_suggestion( |
| "move it to the end of the type declaration", |
| vec![(left_sp, String::new()), (right_sp, sugg)], |
| Applicability::MachineApplicable, |
| ), |
| None => diag.span_suggestion( |
| left_sp, |
| "remove this `where`", |
| "", |
| Applicability::MachineApplicable, |
| ), |
| }; |
| diag.note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information"); |
| } |
| BuiltinLintDiag::SingleUseLifetime { |
| param_span, |
| use_span: Some((use_span, elide)), |
| deletion_span, |
| } => { |
| debug!(?param_span, ?use_span, ?deletion_span); |
| diag.span_label(param_span, "this lifetime..."); |
| diag.span_label(use_span, "...is used only here"); |
| if let Some(deletion_span) = deletion_span { |
| let msg = "elide the single-use lifetime"; |
| let (use_span, replace_lt) = if elide { |
| let use_span = sess |
| .source_map() |
| .span_extend_while(use_span, char::is_whitespace) |
| .unwrap_or(use_span); |
| (use_span, String::new()) |
| } else { |
| (use_span, "'_".to_owned()) |
| }; |
| debug!(?deletion_span, ?use_span); |
| |
| // issue 107998 for the case such as a wrong function pointer type |
| // `deletion_span` is empty and there is no need to report lifetime uses here |
| let suggestions = if deletion_span.is_empty() { |
| vec![(use_span, replace_lt)] |
| } else { |
| vec![(deletion_span, String::new()), (use_span, replace_lt)] |
| }; |
| diag.multipart_suggestion(msg, suggestions, Applicability::MachineApplicable); |
| } |
| } |
| BuiltinLintDiag::SingleUseLifetime { param_span: _, use_span: None, deletion_span } => { |
| debug!(?deletion_span); |
| if let Some(deletion_span) = deletion_span { |
| diag.span_suggestion( |
| deletion_span, |
| "elide the unused lifetime", |
| "", |
| Applicability::MachineApplicable, |
| ); |
| } |
| } |
| BuiltinLintDiag::NamedArgumentUsedPositionally { |
| position_sp_to_replace, |
| position_sp_for_msg, |
| named_arg_sp, |
| named_arg_name, |
| is_formatting_arg, |
| } => { |
| diag.span_label( |
| named_arg_sp, |
| "this named argument is referred to by position in formatting string", |
| ); |
| if let Some(positional_arg_for_msg) = position_sp_for_msg { |
| let msg = format!( |
| "this formatting argument uses named argument `{named_arg_name}` by position" |
| ); |
| diag.span_label(positional_arg_for_msg, msg); |
| } |
| |
| if let Some(positional_arg_to_replace) = position_sp_to_replace { |
| let name = if is_formatting_arg { named_arg_name + "$" } else { named_arg_name }; |
| let span_to_replace = if let Ok(positional_arg_content) = |
| sess.source_map().span_to_snippet(positional_arg_to_replace) |
| && positional_arg_content.starts_with(':') |
| { |
| positional_arg_to_replace.shrink_to_lo() |
| } else { |
| positional_arg_to_replace |
| }; |
| diag.span_suggestion_verbose( |
| span_to_replace, |
| "use the named argument by name to avoid ambiguity", |
| name, |
| Applicability::MaybeIncorrect, |
| ); |
| } |
| } |
| BuiltinLintDiag::ByteSliceInPackedStructWithDerive => { |
| diag.help("consider implementing the trait by hand, or remove the `packed` attribute"); |
| } |
| BuiltinLintDiag::UnusedExternCrate { removal_span } => { |
| diag.span_suggestion(removal_span, "remove it", "", Applicability::MachineApplicable); |
| } |
| BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => { |
| let suggestion_span = vis_span.between(ident_span); |
| diag.span_suggestion_verbose( |
| suggestion_span, |
| "convert it to a `use`", |
| if vis_span.is_empty() { "use " } else { " use " }, |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => { |
| rustc_errors::report_ambiguity_error(diag, ambiguity); |
| } |
| BuiltinLintDiag::AmbiguousGlobReexports { |
| name, |
| namespace, |
| first_reexport_span, |
| duplicate_reexport_span, |
| } => { |
| diag.span_label( |
| first_reexport_span, |
| format!("the name `{name}` in the {namespace} namespace is first re-exported here"), |
| ); |
| diag.span_label( |
| duplicate_reexport_span, |
| format!( |
| "but the name `{name}` in the {namespace} namespace is also re-exported here" |
| ), |
| ); |
| } |
| BuiltinLintDiag::HiddenGlobReexports { |
| name, |
| namespace, |
| glob_reexport_span, |
| private_item_span, |
| } => { |
| diag.span_note(glob_reexport_span, format!("the name `{name}` in the {namespace} namespace is supposed to be publicly re-exported here")); |
| diag.span_note(private_item_span, "but the private item here shadows it".to_owned()); |
| } |
| BuiltinLintDiag::UnusedQualifications { removal_span } => { |
| diag.span_suggestion_verbose( |
| removal_span, |
| "remove the unnecessary path segments", |
| "", |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::AssociatedConstElidedLifetime { elided, span } => { |
| diag.span_suggestion_verbose( |
| if elided { span.shrink_to_hi() } else { span }, |
| "use the `'static` lifetime", |
| if elided { "'static " } else { "'static" }, |
| Applicability::MachineApplicable, |
| ); |
| } |
| BuiltinLintDiag::RedundantImportVisibility { max_vis, span } => { |
| diag.span_note(span, format!("the most public imported item is `{max_vis}`")); |
| diag.help( |
| "reduce the glob import's visibility or increase visibility of imported items", |
| ); |
| } |
| } |
| } |
