rustc_middle/

lint.rs

use std::cmp::min;

use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::sorted_map::SortedMap;
use rustc_errors::{Diag, Diagnostic, EmissionOverride, MultiSpan};
use rustc_hir::{HirId, ItemLocalId};
use rustc_lint_defs::{
    EditionFcw, FutureIncompatibilityReason, Level, Lint, LintExpectationId, LintId,
    StableLintExpectationId, UnstableLintExpectationId, builtin,
};
use rustc_macros::{Decodable, Encodable, StableHash};
use rustc_session::Session;
use rustc_span::{DUMMY_SP, ExpnKind, Span, Symbol, kw, sym};
use rustc_structures::LintName;
use tracing::instrument;

use crate::ty::TyCtxt;

/// How a lint level was set.
#[derive(Clone, Copy, PartialEq, Eq, Encodable, Decodable, StableHash, Debug)]
pub enum LintLevelSource {
    /// Lint is at the default level as declared in rustc.
    Default,

    /// Lint level was set by an attribute.
    Node {
        name: LintName,
        span: Span,
        /// RFC 2383 reason
        reason: Option<Symbol>,
    },

    /// Lint level was set by a command-line flag.
    /// The provided `Level` is the level specified on the command line.
    /// (The actual level may be lower due to `--cap-lints`.)
    CommandLine(LintName, Level),
}

impl LintLevelSource {
    pub fn name(self) -> LintName {
        match self {
            LintLevelSource::Default => LintName { tool: None, name: kw::Default },
            LintLevelSource::Node { name, .. } => name,
            LintLevelSource::CommandLine(name, _) => name,
        }
    }

    pub fn span(self) -> Span {
        match self {
            LintLevelSource::Default => DUMMY_SP,
            LintLevelSource::Node { span, .. } => span,
            LintLevelSource::CommandLine(_, _) => DUMMY_SP,
        }
    }
}

/// Convenience helper for things that are frequently used together.
#[derive(Copy, Clone, Debug, StableHash, Encodable, Decodable)]
pub struct LevelSpec<Id = LintExpectationId> {
    // This field *must* be private. It must be set in tandem with `lint_id`, only in
    // `LevelSpec::new`, because only certain `level`/`lint_id` combinations are valid. See
    // `LevelSpec::new` for those combinations.
    //
    // If you are thinking right now that `level` and `lint_id` should be combined into a single
    // type that excludes the invalid combinations, that's a reasonable thought, but in practice
    // it's painful because `level` needs to be used by itself, without `lint_id`, in many places.
    // Making the fields private prevents invalid combinations while retaining the flexibility of
    // two separate fields.
    level: Level,

    // This field *must* be private. See the comment on `level`.
    lint_id: Option<Id>,

    pub src: LintLevelSource,
}

pub type UnstableLevelSpec = LevelSpec<UnstableLintExpectationId>;
pub type StableLevelSpec = LevelSpec<StableLintExpectationId>;

impl<Id: Copy> LevelSpec<Id> {
    // Panics if an invalid `level`/`lint_id` combination is given.
    pub fn new(level: Level, lint_id: Option<Id>, src: LintLevelSource) -> LevelSpec<Id> {
        match (level, lint_id) {
            (Level::Allow | Level::Warn | Level::Deny | Level::Forbid, None) => {}
            (Level::Expect, Some(_)) => {}
            (Level::ForceWarn, _) => {}
            _ => panic!("invalid level/lint_id combination"),
        }
        LevelSpec { level, lint_id, src }
    }

    pub fn level(self) -> Level {
        self.level
    }

    pub fn is_allow(self) -> bool {
        self.level == Level::Allow
    }

    pub fn is_expect(self) -> bool {
        self.level == Level::Expect
    }

    pub fn lint_id(self) -> Option<Id> {
        self.lint_id
    }
}

impl From<UnstableLevelSpec> for LevelSpec {
    fn from(level: UnstableLevelSpec) -> LevelSpec {
        let LevelSpec { level, lint_id, src } = level;
        let lint_id = lint_id.map(LintExpectationId::Unstable);
        LevelSpec { level, lint_id, src }
    }
}

impl From<StableLevelSpec> for LevelSpec {
    fn from(level: StableLevelSpec) -> LevelSpec {
        let LevelSpec { level, lint_id, src } = level;
        let lint_id = lint_id.map(LintExpectationId::Stable);
        LevelSpec { level, lint_id, src }
    }
}

/// Return type for the `shallow_lint_levels_on` query.
///
/// This map represents lints levels given by the attributes for *a single HirId*.
#[derive(Default, Debug, StableHash)]
pub struct ShallowLintLevelMap {
    // All the specs for this HirId. This is accessed frequently, e.g. for every lint emitted.
    pub specs: SortedMap<ItemLocalId, FxIndexMap<LintId, StableLevelSpec>>,

    // Additional information about the `expect` specs for this HirId. This is consulted only once
    // per compilation session, in `check_expectations`/`lint_expectations`.
    pub expectations: Vec<(StableLintExpectationId, LintExpectation)>,
}

/// Verify the effect of special annotations: `warnings` lint level and lint caps.
///
/// The return of this function is suitable for diagnostics.
pub fn reveal_actual_level_spec<Id: Copy>(
    sess: &Session,
    lint: LintId,
    probe_for_lint_level_spec: impl Fn(LintId) -> Option<LevelSpec<Id>>,
) -> LevelSpec<Id> {
    let level_spec = probe_for_lint_level_spec(lint);

    // If `level` is none then we actually assume the default level for this lint.
    let mut level_spec = level_spec.unwrap_or_else(|| {
        LevelSpec::new(lint.lint.default_level(sess.edition()), None, LintLevelSource::Default)
    });

    // If we're about to issue a warning, check at the last minute for any
    // directives against the `warnings` lint group. If, for example, there's an
    // `allow(warnings)` in scope then we want to respect that instead.
    if level_spec.level == Level::Warn {
        if let Some(configured_level_spec) =
            probe_for_lint_level_spec(LintId::of(builtin::WARNINGS))
        {
            let respect_warnings_lint_group = match configured_level_spec.level {
                // -Wwarnings is a no-op.
                Level::Warn => false,
                // Some warnings cannot be denied from the `warnings` lint group, only individually.
                Level::Deny | Level::Forbid => !lint.lint.ignore_deny_warnings,
                // All warnings respect -Awarnings.
                Level::Allow => true,
                // Not sure what the right behavior is here, but, sure, why not.
                // See tests/ui/lint/rfc-2383-lint-reason/expect_warnings.rs.
                Level::Expect => true,
                Level::ForceWarn => {
                    sess.dcx().delayed_bug("cannot --force-warn the `warnings` lint group");
                    false
                }
            };
            if respect_warnings_lint_group {
                level_spec = configured_level_spec;
            }
        }
    }

    // Ensure that we never exceed the `--cap-lints` argument unless the source is a --force-warn
    if !matches!(level_spec.src, LintLevelSource::CommandLine(_, Level::ForceWarn)) {
        level_spec.level = min(level_spec.level, sess.opts.lint_cap.unwrap_or(Level::Forbid));
    };

    // Ensure that we never exceed driver level.
    if let Some(driver_level) = sess.driver_lint_caps.get(&lint) {
        level_spec.level = min(level_spec.level, *driver_level);
    }

    level_spec
}

impl ShallowLintLevelMap {
    /// Perform a deep probe in the HIR tree looking for the actual level spec for the lint.
    /// This lint level spec is not usable for diagnostics, it needs to be corrected by
    /// `reveal_actual_level` beforehand.
    #[instrument(level = "trace", skip(self, tcx), ret)]
    fn probe_for_lint_level_spec(
        &self,
        tcx: TyCtxt<'_>,
        id: LintId,
        start: HirId,
    ) -> Option<StableLevelSpec> {
        if let Some(map) = self.specs.get(&start.local_id)
            && let Some(level_spec) = map.get(&id)
        {
            return Some(*level_spec);
        }

        let mut owner = start.owner;
        let mut specs = &self.specs;

        for parent in tcx.hir_parent_id_iter(start) {
            if parent.owner != owner {
                owner = parent.owner;
                specs = &tcx.shallow_lint_levels_on(owner).specs;
            }
            if let Some(map) = specs.get(&parent.local_id)
                && let Some(level_spec) = map.get(&id)
            {
                return Some(*level_spec);
            }
        }

        None
    }

    /// Fetch and return the user-visible lint level spec for the given lint at the given HirId.
    #[instrument(level = "trace", skip(self, tcx), ret)]
    pub fn lint_level_spec_at_node(
        &self,
        tcx: TyCtxt<'_>,
        lint: LintId,
        cur: HirId,
    ) -> StableLevelSpec {
        reveal_actual_level_spec(tcx.sess, lint, |lint| {
            self.probe_for_lint_level_spec(tcx, lint, cur)
        })
    }
}

impl TyCtxt<'_> {
    /// Fetch and return the user-visible lint level spec for the given lint at the given HirId.
    pub fn lint_level_spec_at_node(self, lint: &'static Lint, id: HirId) -> StableLevelSpec {
        self.shallow_lint_levels_on(id.owner).lint_level_spec_at_node(self, LintId::of(lint), id)
    }
}

/// This struct represents a lint expectation and holds all required information
/// to emit the `unfulfilled_lint_expectations` lint if it is unfulfilled after
/// the `LateLintPass` has completed.
#[derive(Clone, Debug, Encodable, Decodable, StableHash)]
pub struct LintExpectation {
    /// The reason for this expectation that can optionally be added as part of
    /// the attribute. It will be displayed as part of the lint message.
    pub reason: Option<Symbol>,
    /// The [`Span`] of the attribute that this expectation originated from.
    pub emission_span: Span,
    /// Lint messages for the `unfulfilled_lint_expectations` lint will be
    /// adjusted to include an additional note. Therefore, we have to track if
    /// the expectation is for the lint.
    pub is_unfulfilled_lint_expectations: bool,
    /// This will hold the name of the tool that this lint belongs to. For
    /// the lint `clippy::some_lint` the tool would be `clippy`, the same
    /// goes for `rustdoc`. This will be `None` for rustc lints
    pub lint_tool: Option<Symbol>,
}

impl LintExpectation {
    pub fn new(
        reason: Option<Symbol>,
        emission_span: Span,
        is_unfulfilled_lint_expectations: bool,
        lint_tool: Option<Symbol>,
    ) -> Self {
        Self { reason, emission_span, is_unfulfilled_lint_expectations, lint_tool }
    }
}

fn explain_lint_level_source(
    sess: &Session,
    lint: &'static Lint,
    level: Level,
    src: LintLevelSource,
    err: &mut Diag<'_>,
) {
    // Find the name of the lint group that contains the given lint.
    // Assumes the lint only belongs to one group.
    let lint_group_name = |lint| {
        let lint_groups_iter = sess.lint_groups_iter();
        let lint_id = LintId::of(lint);
        lint_groups_iter
            .filter(|lint_group| !lint_group.is_externally_loaded)
            .find(|lint_group| {
                lint_group
                    .lints
                    .iter()
                    .find(|lint_group_lint| **lint_group_lint == lint_id)
                    .is_some()
            })
            .map(|lint_group| lint_group.name)
    };
    let name = LintName::from_str(&lint.name_lower());
    if let Level::Allow = level {
        // Do not point at `#[allow(compat_lint)]` as the reason for a compatibility lint
        // triggering. (#121009)
        return;
    }
    match src {
        LintLevelSource::Default => {
            let level_str = level.as_str();
            match lint_group_name(lint) {
                Some(group_name) => {
                    err.note_once(format!("`#[{level_str}({name})]` (part of `#[{level_str}({group_name})]`) on by default"));
                }
                None => {
                    err.note_once(format!("`#[{level_str}({name})]` on by default"));
                }
            }
        }
        LintLevelSource::CommandLine(lint_flag_val, orig_level) => {
            let flag = orig_level.to_cmd_flag();
            let hyphen_case_lint_name = name.to_string().replace('_', "-");
            if lint_flag_val == name {
                err.note_once(format!(
                    "requested on the command line with `{flag} {hyphen_case_lint_name}`"
                ));
            } else {
                let hyphen_case_flag_val = lint_flag_val.to_string().replace('_', "-");
                err.note_once(format!(
                    "`{flag} {hyphen_case_lint_name}` implied by `{flag} {hyphen_case_flag_val}`"
                ));
                if matches!(orig_level, Level::Warn | Level::Deny) {
                    let help = if name.is(sym::dead_code) {
                        format!(
                            "to override `{flag} {hyphen_case_flag_val}` add `#[expect({name})]` or `#[allow({name})]`"
                        )
                    } else {
                        format!(
                            "to override `{flag} {hyphen_case_flag_val}` add `#[allow({name})]`"
                        )
                    };
                    err.help_once(help);
                }
            }
        }
        LintLevelSource::Node { name: lint_attr_name, span, reason, .. } => {
            if let Some(rationale) = reason {
                err.note(rationale.to_string());
            }
            err.span_note_once(span, "the lint level is defined here");
            if lint_attr_name != name {
                let level_str = level.as_str();
                err.note_once(format!(
                    "`#[{level_str}({name})]` implied by `#[{level_str}({lint_attr_name})]`"
                ));
            }
        }
    }

    if let Some(warnings_group) = sess
        .opts
        .lint_opts
        .iter()
        .find_map(|(opt, level)| (opt == "warnings").then_some(level))
        .copied()
        && warnings_group >= Level::Deny
        && level < warnings_group
    {
        err.note_once(format!("the `{name}` lint ignores `-D warnings`"));
    }
}

/// The innermost function for emitting lints implementing the [`trait@Diagnostic`] trait.
///
/// If you are looking to implement a lint, look for higher level functions,
/// for example:
///
/// - [`TyCtxt::emit_node_span_lint`]
/// - `LintContext::opt_span_lint`
#[track_caller]
pub fn emit_lint_base<'a, D: Diagnostic<'a> + 'a>(
    sess: &'a Session,
    lint: &'static Lint,
    level_spec: impl Into<LevelSpec>,
    span: Option<MultiSpan>,
    decorate: D,
) {
    // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to
    // the "real" work.
    #[track_caller]
    fn emit_lint_base_impl<'a>(
        sess: &'a Session,
        lint: &'static Lint,
        level_spec: LevelSpec,
        span: Option<MultiSpan>,
        decorate: Box<
            dyn FnOnce(rustc_errors::DiagCtxtHandle<'a>, rustc_errors::Level) -> Diag<'a> + 'a,
        >,
    ) {
        let LevelSpec { level, lint_id, src } = level_spec;

        // Check for future incompatibility lints and issue a stronger warning.
        let future_incompatible = lint.future_incompatible;

        let has_future_breakage = future_incompatible.map_or(
            // Default allow lints trigger too often for testing.
            sess.opts.unstable_opts.future_incompat_test && lint.default_level != Level::Allow,
            |incompat| incompat.report_in_deps,
        );

        // Convert lint level to error level.
        let err_level = match level {
            Level::Allow => {
                if has_future_breakage {
                    rustc_errors::Level::Warning(Some(EmissionOverride::Allowed))
                } else {
                    return;
                }
            }
            Level::Expect => {
                // This case is special as we actually allow the lint itself in this context, but
                // we can't return early like in the case for `Level::Allow` because we still
                // need the lint diagnostic to be emitted to `rustc_error::DiagCtxtInner`.
                //
                // We also cannot mark the lint expectation as fulfilled here right away, because
                // it can still be cancelled in the decorate function. So we create a `Diag` and
                // continue as we would for `Level::Warn`.
                rustc_errors::Level::Warning(Some(EmissionOverride::Expected {
                    lint_id: lint_id.unwrap(),
                }))
            }
            Level::ForceWarn => {
                rustc_errors::Level::Warning(Some(EmissionOverride::Forced { lint_id }))
            }
            Level::Warn => rustc_errors::Level::Warning(None),
            Level::Deny | Level::Forbid => rustc_errors::Level::Error,
        };

        let disable_suggestions = if let Some(ref span) = span
            // If this code originates in a foreign macro, aka something that this crate
            // did not itself author, then it's likely that there's nothing this crate
            // can do about it. We probably want to skip the lint entirely.
            && span.primary_spans().iter().any(|s| s.in_external_macro(sess.source_map()))
        {
            true
        } else {
            false
        };

        if disable_suggestions {
            // If this is a future incompatible that is not an edition fixing lint
            // it'll become a hard error, so we have to emit *something*. Also,
            // if this lint occurs in the expansion of a macro from an external crate,
            // allow individual lints to opt-out from being reported.
            let incompatible = future_incompatible.is_some_and(|f| f.reason.edition().is_none());

            // In rustc, for the find_attr macro, we want to always emit this.
            // This completely circumvents normal lint checking, which usually doesn't happen for macros from other crates.
            // However, we kind of want that when using find_attr from another rustc crate. So we cheat a little.
            let is_in_find_attr = sess.enable_internal_lints()
                && span.as_ref().is_some_and(|span| {
                    span.primary_spans().iter().any(|s| {
                        s.source_callee().is_some_and(|i| {
                            matches!(i.kind, ExpnKind::Macro(_, name) if name.as_str() == "find_attr")
                        })
                    })
                });

            if !incompatible && !lint.report_in_external_macro && !is_in_find_attr {
                // Don't continue further, since we don't want to have
                // `diag_span_note_once` called for a diagnostic that isn't emitted.
                return;
            }
        }
        // Finally, run `decorate`. `decorate` can call `trimmed_path_str` (directly or indirectly),
        // so we need to make sure when we do call `decorate` that the diagnostic is eventually
        // emitted or we'll get a `must_produce_diag` ICE.
        //
        // When is a diagnostic *eventually* emitted? Well, that is determined by 2 factors:
        // 1. If the corresponding `rustc_errors::Level` is beyond warning, i.e. `Error`, then the
        //    diagnostic will be emitted regardless of CLI options.
        // 2. If the corresponding `rustc_errors::Level` is warning, then that can be affected by
        //    `-A warnings` or `--cap-lints=xxx` on the command line. In which case, the diagnostic
        //    will be emitted if `can_emit_warnings` is true.
        let skip =
            err_level == rustc_errors::Level::Warning(None) && !sess.dcx().can_emit_warnings();

        let mut err: Diag<'_> = if !skip {
            decorate(sess.dcx(), err_level)
        } else {
            Diag::new(sess.dcx(), err_level, "")
        };

        if let Some(span) = span
            && err.span.primary_span().is_none()
        {
            // We can't use `err.span()` because it overwrites the labels, so we need to do it
            // manually.
            for primary in span.primary_spans() {
                err.span.push_primary_span(*primary);
            }
            for (label_span, label) in span.span_labels_raw() {
                err.span.push_span_diag(*label_span, label.clone());
            }
            for span in span.span_context() {
                err.span.push_span_context(*span);
            }
        }

        if disable_suggestions {
            // Any suggestions made here are likely to be incorrect, so anything we
            // emit shouldn't be automatically fixed by rustfix.
            err.disable_suggestions();
        }

        err.is_lint(lint.name_lower(), has_future_breakage, lint.rust_version);
        // Lint diagnostics that are covered by the expect level will not be emitted outside
        // the compiler. It is therefore not necessary to add any information for the user.
        // This will therefore directly call the decorate function which will in turn emit
        // the diagnostic.
        if let Level::Expect = level {
            err.emit();
            return;
        }

        if let Some(future_incompatible) = future_incompatible {
            let explanation = match future_incompatible.reason {
                FutureIncompatibilityReason::FutureReleaseError(_) => {
                    "this was previously accepted by the compiler but is being phased out; \
                         it will become a hard error in a future release!"
                        .to_owned()
                }
                FutureIncompatibilityReason::FutureReleaseSemanticsChange(_) => {
                    "this will change its meaning in a future release!".to_owned()
                }
                FutureIncompatibilityReason::EditionError(EditionFcw { edition, .. }) => {
                    let current_edition = sess.edition();
                    format!(
                        "this is accepted in the current edition (Rust {current_edition}) but is a hard error in Rust {edition}!"
                    )
                }
                FutureIncompatibilityReason::EditionSemanticsChange(EditionFcw {
                    edition, ..
                }) => {
                    format!("this changes meaning in Rust {edition}")
                }
                FutureIncompatibilityReason::EditionAndFutureReleaseError(EditionFcw {
                    edition,
                    ..
                }) => {
                    format!(
                        "this was previously accepted by the compiler but is being phased out; \
                         it will become a hard error in Rust {edition} and in a future release in all editions!"
                    )
                }
                FutureIncompatibilityReason::EditionAndFutureReleaseSemanticsChange(
                    EditionFcw { edition, .. },
                ) => {
                    format!(
                        "this changes meaning in Rust {edition} and in a future release in all editions!"
                    )
                }
                FutureIncompatibilityReason::Custom(reason, _) => reason.to_owned(),
            };

            if future_incompatible.explain_reason {
                err.warn(explanation);
            }

            let citation =
                format!("for more information, see {}", future_incompatible.reason.reference());
            err.note(citation);
        }

        explain_lint_level_source(sess, lint, level, src, &mut err);
        err.emit();
    }
    emit_lint_base_impl(
        sess,
        lint,
        level_spec.into(),
        span,
        Box::new(move |dcx, level| decorate.into_diag(dcx, level)),
    );
}