3 use rustc_data_structures::fx::FxHashMap;
4 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
5 use rustc_errors::{DiagnosticBuilder, DiagnosticId};
7 use rustc_index::vec::IndexVec;
8 use rustc_query_system::ich::StableHashingContext;
9 use rustc_session::lint::{
10 builtin::{self, FORBIDDEN_LINT_GROUPS},
11 FutureIncompatibilityReason, Level, Lint, LintId,
13 use rustc_session::{DiagnosticMessageId, Session};
14 use rustc_span::hygiene::MacroKind;
15 use rustc_span::source_map::{DesugaringKind, ExpnKind, MultiSpan};
16 use rustc_span::{symbol, Span, Symbol, DUMMY_SP};
18 /// How a lint level was set.
19 #[derive(Clone, Copy, PartialEq, Eq, HashStable, Debug)]
20 pub enum LintLevelSource {
21 /// Lint is at the default level as declared
22 /// in rustc or a plugin.
25 /// Lint level was set by an attribute.
26 Node(Symbol, Span, Option<Symbol> /* RFC 2383 reason */),
28 /// Lint level was set by a command-line flag.
29 /// The provided `Level` is the level specified on the command line.
30 /// (The actual level may be lower due to `--cap-lints`.)
31 CommandLine(Symbol, Level),
34 impl LintLevelSource {
35 pub fn name(&self) -> Symbol {
37 LintLevelSource::Default => symbol::kw::Default,
38 LintLevelSource::Node(name, _, _) => name,
39 LintLevelSource::CommandLine(name, _) => name,
43 pub fn span(&self) -> Span {
45 LintLevelSource::Default => DUMMY_SP,
46 LintLevelSource::Node(_, span, _) => span,
47 LintLevelSource::CommandLine(_, _) => DUMMY_SP,
52 /// A tuple of a lint level and its source.
53 pub type LevelAndSource = (Level, LintLevelSource);
55 #[derive(Debug, HashStable)]
56 pub struct LintLevelSets {
57 pub list: IndexVec<LintStackIndex, LintSet>,
61 rustc_index::newtype_index! {
63 pub struct LintStackIndex {
64 const COMMAND_LINE = 0,
68 #[derive(Debug, HashStable)]
70 // -A,-W,-D flags, a `Symbol` for the flag itself and `Level` for which
72 pub specs: FxHashMap<LintId, LevelAndSource>,
74 pub parent: LintStackIndex,
78 pub fn new() -> Self {
79 LintLevelSets { list: IndexVec::new(), lint_cap: Level::Forbid }
82 pub fn get_lint_level(
86 aux: Option<&FxHashMap<LintId, LevelAndSource>>,
89 let (level, mut src) = self.get_lint_id_level(LintId::of(lint), idx, aux);
91 // If `level` is none then we actually assume the default level for this
93 let mut level = level.unwrap_or_else(|| lint.default_level(sess.edition()));
95 // If we're about to issue a warning, check at the last minute for any
96 // directives against the warnings "lint". If, for example, there's an
97 // `allow(warnings)` in scope then we want to respect that instead.
99 // We exempt `FORBIDDEN_LINT_GROUPS` from this because it specifically
100 // triggers in cases (like #80988) where you have `forbid(warnings)`,
101 // and so if we turned that into an error, it'd defeat the purpose of the
102 // future compatibility warning.
103 if level == Level::Warn && LintId::of(lint) != LintId::of(FORBIDDEN_LINT_GROUPS) {
104 let (warnings_level, warnings_src) =
105 self.get_lint_id_level(LintId::of(builtin::WARNINGS), idx, aux);
106 if let Some(configured_warning_level) = warnings_level {
107 if configured_warning_level != Level::Warn {
108 level = configured_warning_level;
114 // Ensure that we never exceed the `--cap-lints` argument
115 // unless the source is a --force-warn
116 level = if let LintLevelSource::CommandLine(_, Level::ForceWarn) = src {
119 cmp::min(level, self.lint_cap)
122 if let Some(driver_level) = sess.driver_lint_caps.get(&LintId::of(lint)) {
123 // Ensure that we never exceed driver level.
124 level = cmp::min(*driver_level, level);
130 pub fn get_lint_id_level(
133 mut idx: LintStackIndex,
134 aux: Option<&FxHashMap<LintId, LevelAndSource>>,
135 ) -> (Option<Level>, LintLevelSource) {
136 if let Some(specs) = aux {
137 if let Some(&(level, src)) = specs.get(&id) {
138 return (Some(level), src);
142 let LintSet { ref specs, parent } = self.list[idx];
143 if let Some(&(level, src)) = specs.get(&id) {
144 return (Some(level), src);
146 if idx == COMMAND_LINE {
147 return (None, LintLevelSource::Default);
155 pub struct LintLevelMap {
156 pub sets: LintLevelSets,
157 pub id_to_set: FxHashMap<HirId, LintStackIndex>,
161 /// If the `id` was previously registered with `register_id` when building
162 /// this `LintLevelMap` this returns the corresponding lint level and source
163 /// of the lint level for the lint provided.
165 /// If the `id` was not previously registered, returns `None`. If `None` is
166 /// returned then the parent of `id` should be acquired and this function
167 /// should be called again.
168 pub fn level_and_source(
173 ) -> Option<LevelAndSource> {
174 self.id_to_set.get(&id).map(|idx| self.sets.get_lint_level(lint, *idx, None, session))
178 impl<'a> HashStable<StableHashingContext<'a>> for LintLevelMap {
180 fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
181 let LintLevelMap { ref sets, ref id_to_set } = *self;
183 id_to_set.hash_stable(hcx, hasher);
185 hcx.while_hashing_spans(true, |hcx| sets.hash_stable(hcx, hasher))
189 pub struct LintDiagnosticBuilder<'a>(DiagnosticBuilder<'a>);
191 impl<'a> LintDiagnosticBuilder<'a> {
192 /// Return the inner DiagnosticBuilder, first setting the primary message to `msg`.
193 pub fn build(mut self, msg: &str) -> DiagnosticBuilder<'a> {
194 self.0.set_primary_message(msg);
195 self.0.set_is_lint();
199 /// Create a LintDiagnosticBuilder from some existing DiagnosticBuilder.
200 pub fn new(err: DiagnosticBuilder<'a>) -> LintDiagnosticBuilder<'a> {
201 LintDiagnosticBuilder(err)
205 pub fn explain_lint_level_source<'s>(
209 src: LintLevelSource,
210 err: &mut DiagnosticBuilder<'s>,
212 let name = lint.name_lower();
214 LintLevelSource::Default => {
217 DiagnosticMessageId::from(lint),
218 &format!("`#[{}({})]` on by default", level.as_str(), name),
221 LintLevelSource::CommandLine(lint_flag_val, orig_level) => {
222 let flag = match orig_level {
225 Level::Forbid => "-F",
226 Level::Allow => "-A",
227 Level::ForceWarn => "--force-warn",
229 let hyphen_case_lint_name = name.replace('_', "-");
230 if lint_flag_val.as_str() == name {
233 DiagnosticMessageId::from(lint),
235 "requested on the command line with `{} {}`",
236 flag, hyphen_case_lint_name
240 let hyphen_case_flag_val = lint_flag_val.as_str().replace('_', "-");
243 DiagnosticMessageId::from(lint),
245 "`{} {}` implied by `{} {}`",
246 flag, hyphen_case_lint_name, flag, hyphen_case_flag_val
251 LintLevelSource::Node(lint_attr_name, src, reason) => {
252 if let Some(rationale) = reason {
253 err.note(rationale.as_str());
255 sess.diag_span_note_once(
257 DiagnosticMessageId::from(lint),
259 "the lint level is defined here",
261 if lint_attr_name.as_str() != name {
262 let level_str = level.as_str();
265 DiagnosticMessageId::from(lint),
267 "`#[{}({})]` implied by `#[{}({})]`",
268 level_str, name, level_str, lint_attr_name
276 pub fn struct_lint_level<'s, 'd>(
280 src: LintLevelSource,
281 span: Option<MultiSpan>,
282 decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>) + 'd,
284 // Avoid codegen bloat from monomorphization by immediately doing dyn dispatch of `decorate` to
286 fn struct_lint_level_impl<'s, 'd>(
290 src: LintLevelSource,
291 span: Option<MultiSpan>,
292 decorate: Box<dyn for<'b> FnOnce(LintDiagnosticBuilder<'b>) + 'd>,
294 // Check for future incompatibility lints and issue a stronger warning.
295 let future_incompatible = lint.future_incompatible;
297 let has_future_breakage = future_incompatible.map_or(
298 // Default allow lints trigger too often for testing.
299 sess.opts.debugging_opts.future_incompat_test && lint.default_level != Level::Allow,
301 matches!(incompat.reason, FutureIncompatibilityReason::FutureReleaseErrorReportNow)
305 let mut err = match (level, span) {
306 (Level::Allow, span) => {
307 if has_future_breakage {
308 if let Some(span) = span {
309 sess.struct_span_allow(span, "")
311 sess.struct_allow("")
317 (Level::Warn, Some(span)) => sess.struct_span_warn(span, ""),
318 (Level::Warn, None) => sess.struct_warn(""),
319 (Level::ForceWarn, Some(span)) => sess.struct_span_force_warn(span, ""),
320 (Level::ForceWarn, None) => sess.struct_force_warn(""),
321 (Level::Deny | Level::Forbid, Some(span)) => {
322 let mut builder = sess.diagnostic().struct_err_lint("");
323 builder.set_span(span);
326 (Level::Deny | Level::Forbid, None) => sess.diagnostic().struct_err_lint(""),
329 // If this code originates in a foreign macro, aka something that this crate
330 // did not itself author, then it's likely that there's nothing this crate
331 // can do about it. We probably want to skip the lint entirely.
332 if err.span.primary_spans().iter().any(|s| in_external_macro(sess, *s)) {
333 // Any suggestions made here are likely to be incorrect, so anything we
334 // emit shouldn't be automatically fixed by rustfix.
335 err.disable_suggestions();
337 // If this is a future incompatible that is not an edition fixing lint
338 // it'll become a hard error, so we have to emit *something*. Also,
339 // if this lint occurs in the expansion of a macro from an external crate,
340 // allow individual lints to opt-out from being reported.
341 let not_future_incompatible =
342 future_incompatible.map(|f| f.reason.edition().is_some()).unwrap_or(true);
343 if not_future_incompatible && !lint.report_in_external_macro {
345 // Don't continue further, since we don't want to have
346 // `diag_span_note_once` called for a diagnostic that isn't emitted.
351 explain_lint_level_source(sess, lint, level, src, &mut err);
353 let name = lint.name_lower();
354 let is_force_warn = matches!(level, Level::ForceWarn);
355 err.code(DiagnosticId::Lint { name, has_future_breakage, is_force_warn });
357 if let Some(future_incompatible) = future_incompatible {
358 let explanation = match future_incompatible.reason {
359 FutureIncompatibilityReason::FutureReleaseError
360 | FutureIncompatibilityReason::FutureReleaseErrorReportNow => {
361 "this was previously accepted by the compiler but is being phased out; \
362 it will become a hard error in a future release!"
365 FutureIncompatibilityReason::FutureReleaseSemanticsChange => {
366 "this will change its meaning in a future release!".to_owned()
368 FutureIncompatibilityReason::EditionError(edition) => {
369 let current_edition = sess.edition();
371 "this is accepted in the current edition (Rust {}) but is a hard error in Rust {}!",
372 current_edition, edition
375 FutureIncompatibilityReason::EditionSemanticsChange(edition) => {
376 format!("this changes meaning in Rust {}", edition)
378 FutureIncompatibilityReason::Custom(reason) => reason.to_owned(),
381 if future_incompatible.explain_reason {
382 err.warn(&explanation);
384 if !future_incompatible.reference.is_empty() {
386 format!("for more information, see {}", future_incompatible.reference);
391 // Finally, run `decorate`. This function is also responsible for emitting the diagnostic.
392 decorate(LintDiagnosticBuilder::new(err));
394 struct_lint_level_impl(sess, lint, level, src, span, Box::new(decorate))
397 /// Returns whether `span` originates in a foreign crate's external macro.
399 /// This is used to test whether a lint should not even begin to figure out whether it should
400 /// be reported on the current node.
401 pub fn in_external_macro(sess: &Session, span: Span) -> bool {
402 let expn_data = span.ctxt().outer_expn_data();
403 match expn_data.kind {
406 | ExpnKind::Desugaring(DesugaringKind::ForLoop | DesugaringKind::WhileLoop) => false,
407 ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external"
408 ExpnKind::Macro(MacroKind::Bang, _) => {
409 // Dummy span for the `def_site` means it's an external macro.
410 expn_data.def_site.is_dummy() || sess.source_map().is_imported(expn_data.def_site)
412 ExpnKind::Macro { .. } => true, // definitely a plugin