rust/compiler/rustc_lint/src/context/diagnostics.rs

#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::untranslatable_diagnostic)]

use std::borrow::Cow;

use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
use rustc_errors::Applicability;
use rustc_errors::{elided_lifetime_in_path_suggestion, DiagArgValue, MultiSpan};
use rustc_middle::middle::stability;
use rustc_session::lint::{BuiltinLintDiag, Lint};
use rustc_span::BytePos;

use crate::{lints, EarlyContext, LintContext as _};

mod check_cfg;

pub(super) fn emit_buffered_lint(
    ctx: &EarlyContext<'_>,
    lint: &'static Lint,
    span: MultiSpan,
    diagnostic: BuiltinLintDiag,
) {
    let sess = ctx.sess();
    match diagnostic {
        BuiltinLintDiag::UnicodeTextFlow(comment_span, content) => {
            let spans: Vec<_> = content
                .char_indices()
                .filter_map(|(i, c)| {
                    TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
                        let lo = comment_span.lo() + BytePos(2 + i as u32);
                        (c, comment_span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
                    })
                })
                .collect();
            let characters = spans
                .iter()
                .map(|&(c, span)| lints::UnicodeCharNoteSub { span, c_debug: format!("{c:?}") })
                .collect();
            let suggestions = (!spans.is_empty()).then_some(lints::UnicodeTextFlowSuggestion {
                spans: spans.iter().map(|(_c, span)| *span).collect(),
            });
            ctx.emit_span_lint(
                lint,
                span,
                lints::UnicodeTextFlow {
                    comment_span,
                    characters,
                    suggestions,
                    num_codepoints: spans.len(),
                },
            )
        }
        BuiltinLintDiag::AbsPathWithModule(mod_span) => {
            let (replacement, applicability) = match sess.source_map().span_to_snippet(mod_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),
            };
            ctx.emit_span_lint(
                lint,
                span,
                lints::AbsPathWithModule {
                    sugg: lints::AbsPathWithModuleSugg {
                        span: mod_span,
                        applicability,
                        replacement,
                    },
                },
            );
        }
        BuiltinLintDiag::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident } => ctx
            .emit_span_lint(
                lint,
                span,
                lints::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident },
            ),
        BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => ctx
            .emit_span_lint(
                lint,
                span,
                lints::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def },
            ),
        BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::ElidedLifetimesInPaths {
                    subdiag: elided_lifetime_in_path_suggestion(
                        sess.source_map(),
                        n,
                        path_span,
                        incl_angl_brckt,
                        insertion_span,
                    ),
                },
            );
        }
        BuiltinLintDiag::UnknownCrateTypes { span, candidate } => {
            let sugg = candidate.map(|candidate| lints::UnknownCrateTypesSub { span, candidate });
            ctx.emit_span_lint(lint, span, lints::UnknownCrateTypes { sugg });
        }
        BuiltinLintDiag::UnusedImports {
            remove_whole_use,
            num_to_remove,
            remove_spans,
            test_module_span,
            span_snippets,
        } => {
            let sugg = if remove_whole_use {
                lints::UnusedImportsSugg::RemoveWholeUse { span: remove_spans[0] }
            } else {
                lints::UnusedImportsSugg::RemoveImports { remove_spans, num_to_remove }
            };
            let test_module_span =
                test_module_span.map(|span| sess.source_map().guess_head_span(span));

            ctx.emit_span_lint(
                lint,
                span,
                lints::UnusedImports {
                    sugg,
                    test_module_span,
                    num_snippets: span_snippets.len(),
                    span_snippets: DiagArgValue::StrListSepByAnd(
                        span_snippets.into_iter().map(Cow::Owned).collect(),
                    ),
                },
            );
        }
        BuiltinLintDiag::RedundantImport(spans, ident) => {
            let subs = spans
                .into_iter()
                .map(|(span, is_imported)| {
                    (match (span.is_dummy(), is_imported) {
                        (false, true) => lints::RedundantImportSub::ImportedHere,
                        (false, false) => lints::RedundantImportSub::DefinedHere,
                        (true, true) => lints::RedundantImportSub::ImportedPrelude,
                        (true, false) => lints::RedundantImportSub::DefinedPrelude,
                    })(span)
                })
                .collect();
            ctx.emit_span_lint(lint, span, lints::RedundantImport { subs, ident });
        }
        BuiltinLintDiag::DeprecatedMacro {
            suggestion,
            suggestion_span,
            note,
            path,
            since_kind,
        } => {
            let sub = suggestion.map(|suggestion| stability::DeprecationSuggestion {
                span: suggestion_span,
                kind: "macro".to_owned(),
                suggestion,
            });
            ctx.emit_span_lint(
                lint,
                span,
                stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind },
            );
        }
        BuiltinLintDiag::UnusedDocComment(attr_span) => {
            ctx.emit_span_lint(lint, span, lints::UnusedDocComment { span: attr_span });
        }
        BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
            let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };

            ctx.emit_span_lint(
                lint,
                span,
                if is_foreign {
                    lints::PatternsInFnsWithoutBody::Foreign { sub }
                } else {
                    lints::PatternsInFnsWithoutBody::Bodiless { sub }
                },
            );
        }
        BuiltinLintDiag::MissingAbi(label_span, default_abi) => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::MissingAbi { span: label_span, default_abi: default_abi.name() },
            );
        }
        BuiltinLintDiag::LegacyDeriveHelpers(label_span) => {
            ctx.emit_span_lint(lint, span, lints::LegacyDeriveHelpers { span: label_span });
        }
        BuiltinLintDiag::ProcMacroBackCompat { crate_name, fixed_version } => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::ProcMacroBackCompat { crate_name, fixed_version },
            );
        }
        BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::OrPatternsBackCompat { span: suggestion_span, suggestion },
            );
        }
        BuiltinLintDiag::ReservedPrefix(label_span, prefix) => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::ReservedPrefix {
                    label: label_span,
                    suggestion: label_span.shrink_to_hi(),
                    prefix,
                },
            );
        }
        BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, macro_name, invoc_span } => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::UnusedBuiltinAttribute { invoc_span, attr_name, macro_name },
            );
        }
        BuiltinLintDiag::TrailingMacro(is_trailing, name) => {
            ctx.emit_span_lint(lint, span, lints::TrailingMacro { is_trailing, name });
        }
        BuiltinLintDiag::BreakWithLabelAndLoop(sugg_span) => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::BreakWithLabelAndLoop {
                    sub: lints::BreakWithLabelAndLoopSub {
                        left: sugg_span.shrink_to_lo(),
                        right: sugg_span.shrink_to_hi(),
                    },
                },
            );
        }
        BuiltinLintDiag::UnexpectedCfgName(name, value) => {
            ctx.emit_span_lint(lint, span, check_cfg::unexpected_cfg_name(sess, name, value));
        }
        BuiltinLintDiag::UnexpectedCfgValue(name, value) => {
            ctx.emit_span_lint(lint, span, check_cfg::unexpected_cfg_value(sess, name, value));
        }
        BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
            let suggestion = match sugg {
                Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
                    left: left_sp,
                    right: right_sp,
                    sugg,
                },
                None => lints::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp },
            };
            ctx.emit_span_lint(lint, span, lints::DeprecatedWhereClauseLocation { suggestion });
        }
        BuiltinLintDiag::SingleUseLifetime {
            param_span,
            use_span: Some((use_span, elide)),
            deletion_span,
            ident,
        } => {
            debug!(?param_span, ?use_span, ?deletion_span);
            let suggestion = if let Some(deletion_span) = deletion_span {
                let (use_span, replace_lt) = if elide {
                    let use_span = sess.source_map().span_extend_while_whitespace(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 deletion_span =
                    if deletion_span.is_empty() { None } else { Some(deletion_span) };
                Some(lints::SingleUseLifetimeSugg { deletion_span, use_span, replace_lt })
            } else {
                None
            };

            ctx.emit_span_lint(
                lint,
                span,
                lints::SingleUseLifetime { suggestion, param_span, use_span, ident },
            );
        }
        BuiltinLintDiag::SingleUseLifetime { use_span: None, deletion_span, ident, .. } => {
            debug!(?deletion_span);
            ctx.emit_span_lint(lint, span, lints::UnusedLifetime { deletion_span, ident });
        }
        BuiltinLintDiag::NamedArgumentUsedPositionally {
            position_sp_to_replace,
            position_sp_for_msg,
            named_arg_sp,
            named_arg_name,
            is_formatting_arg,
        } => {
            let (suggestion, name) = if let Some(positional_arg_to_replace) = position_sp_to_replace
            {
                let mut name = named_arg_name.clone();
                if is_formatting_arg {
                    name.push('$')
                };
                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
                };
                (Some(span_to_replace), name)
            } else {
                (None, String::new())
            };

            ctx.emit_span_lint(
                lint,
                span,
                lints::NamedArgumentUsedPositionally {
                    named_arg_sp,
                    position_label_sp: position_sp_for_msg,
                    suggestion,
                    name,
                    named_arg_name,
                },
            )
        }
        BuiltinLintDiag::ByteSliceInPackedStructWithDerive { ty } => {
            ctx.emit_span_lint(lint, span, lints::ByteSliceInPackedStructWithDerive { ty })
        }
        BuiltinLintDiag::UnusedExternCrate { removal_span } => {
            ctx.emit_span_lint(lint, span, lints::UnusedExternCrate { removal_span })
        }
        BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => {
            let suggestion_span = vis_span.between(ident_span);
            let code = if vis_span.is_empty() { "use " } else { " use " };
            ctx.emit_span_lint(
                lint,
                span,
                lints::ExternCrateNotIdiomatic { span: suggestion_span, code },
            );
        }
        BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => {
            ctx.emit_span_lint(lint, span, lints::AmbiguousGlobImports { ambiguity });
        }
        BuiltinLintDiag::AmbiguousGlobReexports {
            name,
            namespace,
            first_reexport_span,
            duplicate_reexport_span,
        } => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::AmbiguousGlobReexports {
                    first_reexport: first_reexport_span,
                    duplicate_reexport: duplicate_reexport_span,
                    name,
                    namespace,
                },
            );
        }
        BuiltinLintDiag::HiddenGlobReexports {
            name,
            namespace,
            glob_reexport_span,
            private_item_span,
        } => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::HiddenGlobReexports {
                    glob_reexport: glob_reexport_span,
                    private_item: private_item_span,

                    name,
                    namespace,
                },
            );
        }
        BuiltinLintDiag::UnusedQualifications { removal_span } => {
            ctx.emit_span_lint(lint, span, lints::UnusedQualifications { removal_span });
        }
        BuiltinLintDiag::AssociatedConstElidedLifetime { elided, span: lt_span } => {
            let lt_span = if elided { lt_span.shrink_to_hi() } else { lt_span };
            let code = if elided { "'static " } else { "'static" };
            ctx.emit_span_lint(
                lint,
                span,
                lints::AssociatedConstElidedLifetime { span: lt_span, code, elided },
            );
        }
        BuiltinLintDiag::RedundantImportVisibility { max_vis, span: vis_span, import_vis } => {
            ctx.emit_span_lint(
                lint,
                span,
                lints::RedundantImportVisibility { span: vis_span, help: (), max_vis, import_vis },
            );
        }
        BuiltinLintDiag::UnknownDiagnosticAttribute { span: typo_span, typo_name } => {
            let typo = typo_name.map(|typo_name| lints::UnknownDiagnosticAttributeTypoSugg {
                span: typo_span,
                typo_name,
            });
            ctx.emit_span_lint(lint, span, lints::UnknownDiagnosticAttribute { typo });
        }
        BuiltinLintDiag::MacroUseDeprecated => {
            ctx.emit_span_lint(lint, span, lints::MacroUseDeprecated)
        }
        BuiltinLintDiag::UnusedMacroUse => ctx.emit_span_lint(lint, span, lints::UnusedMacroUse),
        BuiltinLintDiag::PrivateExternCrateReexport(ident) => {
            ctx.emit_span_lint(lint, span, lints::PrivateExternCrateReexport { ident })
        }
        BuiltinLintDiag::UnusedLabel => ctx.emit_span_lint(lint, span, lints::UnusedLabel),
        BuiltinLintDiag::MacroIsPrivate(ident) => {
            ctx.emit_span_lint(lint, span, lints::MacroIsPrivate { ident })
        }
        BuiltinLintDiag::UnusedMacroDefinition(name) => {
            ctx.emit_span_lint(lint, span, lints::UnusedMacroDefinition { name })
        }
        BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
            ctx.emit_span_lint(lint, span, lints::MacroRuleNeverUsed { n: n + 1, name })
        }
        BuiltinLintDiag::UnstableFeature(msg) => {
            ctx.emit_span_lint(lint, span, lints::UnstableFeature { msg })
        }
        BuiltinLintDiag::AvoidUsingIntelSyntax => {
            ctx.emit_span_lint(lint, span, lints::AvoidIntelSyntax)
        }
        BuiltinLintDiag::AvoidUsingAttSyntax => {
            ctx.emit_span_lint(lint, span, lints::AvoidAttSyntax)
        }
        BuiltinLintDiag::IncompleteInclude => {
            ctx.emit_span_lint(lint, span, lints::IncompleteInclude)
        }
        BuiltinLintDiag::UnnameableTestItems => {
            ctx.emit_span_lint(lint, span, lints::UnnameableTestItems)
        }
        BuiltinLintDiag::DuplicateMacroAttribute => {
            ctx.emit_span_lint(lint, span, lints::DuplicateMacroAttribute)
        }
        BuiltinLintDiag::CfgAttrNoAttributes => {
            ctx.emit_span_lint(lint, span, lints::CfgAttrNoAttributes)
        }
        BuiltinLintDiag::CrateTypeInCfgAttr => {
            ctx.emit_span_lint(lint, span, lints::CrateTypeInCfgAttr)
        }
        BuiltinLintDiag::CrateNameInCfgAttr => {
            ctx.emit_span_lint(lint, span, lints::CrateNameInCfgAttr)
        }
        BuiltinLintDiag::MissingFragmentSpecifier => {
            ctx.emit_span_lint(lint, span, lints::MissingFragmentSpecifier)
        }
        BuiltinLintDiag::MetaVariableStillRepeating(name) => {
            ctx.emit_span_lint(lint, span, lints::MetaVariableStillRepeating { name })
        }
        BuiltinLintDiag::MetaVariableWrongOperator => {
            ctx.emit_span_lint(lint, span, lints::MetaVariableWrongOperator)
        }
        BuiltinLintDiag::DuplicateMatcherBinding => {
            ctx.emit_span_lint(lint, span, lints::DuplicateMatcherBinding)
        }
        BuiltinLintDiag::UnknownMacroVariable(name) => {
            ctx.emit_span_lint(lint, span, lints::UnknownMacroVariable { name })
        }
        BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => ctx.emit_span_lint(
            lint,
            span,
            lints::UnusedCrateDependency { extern_crate, local_crate },
        ),
        BuiltinLintDiag::WasmCAbi => ctx.emit_span_lint(lint, span, lints::WasmCAbi),
        BuiltinLintDiag::IllFormedAttributeInput { suggestions } => ctx.emit_span_lint(
            lint,
            span,
            lints::IllFormedAttributeInput {
                num_suggestions: suggestions.len(),
                suggestions: DiagArgValue::StrListSepByAnd(
                    suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
                ),
            },
        ),
        BuiltinLintDiag::InnerAttributeUnstable { is_macro } => ctx.emit_span_lint(
            lint,
            span,
            if is_macro {
                lints::InnerAttributeUnstable::InnerMacroAttribute
            } else {
                lints::InnerAttributeUnstable::CustomInnerAttribute
            },
        ),
    }
}