rustc_lint/early/

diagnostics.rs

use std::borrow::Cow;

use rustc_errors::{
    Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, Level,
    elided_lifetime_in_path_suggestion,
};
use rustc_hir::lints::{AttributeLintKind, FormatWarning};
use rustc_middle::ty::TyCtxt;
use rustc_session::Session;
use rustc_session::lint::BuiltinLintDiag;
use tracing::debug;

use crate::lints;

mod check_cfg;

/// This is a diagnostic struct that will decorate a `BuiltinLintDiag`
/// Directly creating the lint structs is expensive, using this will only decorate the lint structs when needed.
pub struct DecorateBuiltinLint<'sess, 'tcx> {
    pub sess: &'sess Session,
    pub tcx: Option<TyCtxt<'tcx>>,
    pub diagnostic: BuiltinLintDiag,
}

impl<'a> Diagnostic<'a, ()> for DecorateBuiltinLint<'_, '_> {
    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
        match self.diagnostic {
            BuiltinLintDiag::AbsPathWithModule(mod_span) => {
                let (replacement, applicability) =
                    match self.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),
                    };
                lints::AbsPathWithModule {
                    sugg: lints::AbsPathWithModuleSugg {
                        span: mod_span,
                        applicability,
                        replacement,
                    },
                }
                .into_diag(dcx, level)
            }
            BuiltinLintDiag::ElidedLifetimesInPaths(
                n,
                path_span,
                incl_angl_brckt,
                insertion_span,
            ) => lints::ElidedLifetimesInPaths {
                subdiag: elided_lifetime_in_path_suggestion(
                    self.sess.source_map(),
                    n,
                    path_span,
                    incl_angl_brckt,
                    insertion_span,
                ),
            }
            .into_diag(dcx, level),
            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| self.sess.source_map().guess_head_span(span));

                lints::UnusedImports {
                    sugg,
                    test_module_span,
                    num_snippets: span_snippets.len(),
                    span_snippets: DiagArgValue::StrListSepByAnd(
                        span_snippets.into_iter().map(Cow::Owned).collect(),
                    ),
                }
                .into_diag(dcx, level)
            }
            BuiltinLintDiag::SingleUseLifetime {
                param_span,
                use_span,
                elidable,
                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 elidable {
                        let use_span =
                            self.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
                };

                lints::SingleUseLifetime { suggestion, param_span, use_span, ident }
                    .into_diag(dcx, level)
            }
            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) =
                            self.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())
                    };

                lints::NamedArgumentUsedPositionally {
                    named_arg_sp,
                    position_label_sp: position_sp_for_msg,
                    suggestion,
                    name,
                    named_arg_name,
                }
                .into_diag(dcx, level)
            }

            BuiltinLintDiag::AttributeLint(kind) => {
                DecorateAttrLint { sess: self.sess, tcx: self.tcx, diagnostic: &kind }
                    .into_diag(dcx, level)
            }
        }
    }
}

/// This is a diagnostic struct that will decorate a `AttributeLintKind`
/// Directly creating the lint structs is expensive, using this will only decorate the lint structs when needed.
pub struct DecorateAttrLint<'a, 'sess, 'tcx> {
    pub sess: &'sess Session,
    pub tcx: Option<TyCtxt<'tcx>>,
    pub diagnostic: &'a AttributeLintKind,
}

impl<'a> Diagnostic<'a, ()> for DecorateAttrLint<'_, '_, '_> {
    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
        match self.diagnostic {
            &AttributeLintKind::UnusedDuplicate { this, other, warning } => {
                lints::UnusedDuplicate { this, other, warning }.into_diag(dcx, level)
            }
            AttributeLintKind::IllFormedAttributeInput { suggestions, docs } => {
                lints::IllFormedAttributeInput {
                    num_suggestions: suggestions.len(),
                    suggestions: DiagArgValue::StrListSepByAnd(
                        suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
                    ),
                    has_docs: docs.is_some(),
                    docs: docs.unwrap_or(""),
                }
                .into_diag(dcx, level)
            }
            AttributeLintKind::EmptyAttribute { first_span, attr_path, valid_without_list } => {
                lints::EmptyAttributeList {
                    attr_span: *first_span,
                    attr_path: attr_path.clone(),
                    valid_without_list: *valid_without_list,
                }
                .into_diag(dcx, level)
            }
            AttributeLintKind::InvalidTarget { name, target, applied, only, attr_span } => {
                lints::InvalidTargetLint {
                    name: name.clone(),
                    target,
                    applied: DiagArgValue::StrListSepByAnd(
                        applied.into_iter().map(|i| Cow::Owned(i.to_string())).collect(),
                    ),
                    only,
                    attr_span: *attr_span,
                }
                .into_diag(dcx, level)
            }
            &AttributeLintKind::InvalidStyle {
                ref name,
                is_used_as_inner,
                target,
                target_span,
            } => lints::InvalidAttrStyle {
                name: name.clone(),
                is_used_as_inner,
                target_span: (!is_used_as_inner).then_some(target_span),
                target,
            }
            .into_diag(dcx, level),
            &AttributeLintKind::UnsafeAttrOutsideUnsafe { attribute_name_span, sugg_spans } => {
                lints::UnsafeAttrOutsideUnsafeLint {
                    span: attribute_name_span,
                    suggestion: sugg_spans.map(|(left, right)| {
                        lints::UnsafeAttrOutsideUnsafeSuggestion { left, right }
                    }),
                }
                .into_diag(dcx, level)
            }
            &AttributeLintKind::UnexpectedCfgName(name, value) => {
                check_cfg::unexpected_cfg_name(self.sess, self.tcx, name, value)
                    .into_diag(dcx, level)
            }
            &AttributeLintKind::UnexpectedCfgValue(name, value) => {
                check_cfg::unexpected_cfg_value(self.sess, self.tcx, name, value)
                    .into_diag(dcx, level)
            }
            &AttributeLintKind::DuplicateDocAlias { first_definition } => {
                lints::DocAliasDuplicated { first_defn: first_definition }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocAutoCfgExpectsHideOrShow => {
                lints::DocAutoCfgExpectsHideOrShow.into_diag(dcx, level)
            }

            &AttributeLintKind::AmbiguousDeriveHelpers => {
                lints::AmbiguousDeriveHelpers.into_diag(dcx, level)
            }

            &AttributeLintKind::DocAutoCfgHideShowUnexpectedItem { attr_name } => {
                lints::DocAutoCfgHideShowUnexpectedItem { attr_name }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocAutoCfgHideShowExpectsList { attr_name } => {
                lints::DocAutoCfgHideShowExpectsList { attr_name }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocInvalid => lints::DocInvalid.into_diag(dcx, level),

            &AttributeLintKind::DocUnknownInclude { span, inner, value } => {
                lints::DocUnknownInclude {
                    inner,
                    value,
                    sugg: (span, Applicability::MaybeIncorrect),
                }
                .into_diag(dcx, level)
            }

            &AttributeLintKind::DocUnknownSpotlight { span } => {
                lints::DocUnknownSpotlight { sugg_span: span }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocUnknownPasses { name, span } => {
                lints::DocUnknownPasses { name, note_span: span }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocUnknownPlugins { span } => {
                lints::DocUnknownPlugins { label_span: span }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocUnknownAny { name } => {
                lints::DocUnknownAny { name }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocAutoCfgWrongLiteral => {
                lints::DocAutoCfgWrongLiteral.into_diag(dcx, level)
            }

            &AttributeLintKind::DocTestTakesList => lints::DocTestTakesList.into_diag(dcx, level),

            &AttributeLintKind::DocTestUnknown { name } => {
                lints::DocTestUnknown { name }.into_diag(dcx, level)
            }

            &AttributeLintKind::DocTestLiteral => lints::DocTestLiteral.into_diag(dcx, level),

            &AttributeLintKind::AttrCrateLevelOnly => {
                lints::AttrCrateLevelOnly.into_diag(dcx, level)
            }

            &AttributeLintKind::DoNotRecommendDoesNotExpectArgs => {
                lints::DoNotRecommendDoesNotExpectArgs.into_diag(dcx, level)
            }

            &AttributeLintKind::CrateTypeUnknown { span, suggested } => lints::UnknownCrateTypes {
                sugg: suggested.map(|s| lints::UnknownCrateTypesSuggestion { span, snippet: s }),
            }
            .into_diag(dcx, level),

            &AttributeLintKind::MalformedDoc => lints::MalformedDoc.into_diag(dcx, level),

            &AttributeLintKind::ExpectedNoArgs => lints::ExpectedNoArgs.into_diag(dcx, level),

            &AttributeLintKind::ExpectedNameValue => lints::ExpectedNameValue.into_diag(dcx, level),
            &AttributeLintKind::MalformedOnUnimplementedAttr { span } => {
                lints::MalformedOnUnimplementedAttrLint { span }.into_diag(dcx, level)
            }
            &AttributeLintKind::MalformedOnConstAttr { span } => {
                lints::MalformedOnConstAttrLint { span }.into_diag(dcx, level)
            }
            AttributeLintKind::MalformedDiagnosticFormat { warning } => match warning {
                FormatWarning::PositionalArgument { .. } => {
                    lints::DisallowedPositionalArgument.into_diag(dcx, level)
                }
                FormatWarning::InvalidSpecifier { .. } => {
                    lints::InvalidFormatSpecifier.into_diag(dcx, level)
                }
            },
            AttributeLintKind::DiagnosticWrappedParserError { description, label, span } => {
                lints::WrappedParserError { description, label, span: *span }.into_diag(dcx, level)
            }
            &AttributeLintKind::IgnoredDiagnosticOption { option_name, first_span, later_span } => {
                lints::IgnoredDiagnosticOption { option_name, first_span, later_span }
                    .into_diag(dcx, level)
            }
            &AttributeLintKind::MissingOptionsForOnUnimplemented => {
                lints::MissingOptionsForOnUnimplementedAttr.into_diag(dcx, level)
            }
            &AttributeLintKind::MissingOptionsForOnConst => {
                lints::MissingOptionsForOnConstAttr.into_diag(dcx, level)
            }
            &AttributeLintKind::MalformedOnMoveAttr { span } => {
                lints::MalformedOnMoveAttrLint { span }.into_diag(dcx, level)
            }
            &AttributeLintKind::OnMoveMalformedFormatLiterals { name } => {
                lints::OnMoveMalformedFormatLiterals { name }.into_diag(dcx, level)
            }
            &AttributeLintKind::OnMoveMalformedAttrExpectedLiteralOrDelimiter => {
                lints::OnMoveMalformedAttrExpectedLiteralOrDelimiter.into_diag(dcx, level)
            }
            &AttributeLintKind::MissingOptionsForOnMove => {
                lints::MissingOptionsForOnMoveAttr.into_diag(dcx, level)
            }
        }
    }
}