]>
Commit | Line | Data |
---|---|---|
dfeec247 XL |
1 | use std::cmp; |
2 | ||
3 | use crate::ich::StableHashingContext; | |
4 | use rustc_data_structures::fx::FxHashMap; | |
5 | use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; | |
6 | use rustc_errors::{pluralize, Applicability, DiagnosticBuilder, DiagnosticId}; | |
7 | use rustc_hir::HirId; | |
8 | pub use rustc_session::lint::{builtin, Level, Lint, LintId, LintPass}; | |
9 | use rustc_session::{DiagnosticMessageId, Session}; | |
10 | use rustc_span::hygiene::MacroKind; | |
11 | use rustc_span::source_map::{DesugaringKind, ExpnKind, MultiSpan}; | |
12 | use rustc_span::{Span, Symbol}; | |
13 | ||
14 | /// How a lint level was set. | |
15 | #[derive(Clone, Copy, PartialEq, Eq, HashStable)] | |
16 | pub enum LintSource { | |
17 | /// Lint is at the default level as declared | |
18 | /// in rustc or a plugin. | |
19 | Default, | |
20 | ||
21 | /// Lint level was set by an attribute. | |
22 | Node(Symbol, Span, Option<Symbol> /* RFC 2383 reason */), | |
23 | ||
24 | /// Lint level was set by a command-line flag. | |
25 | CommandLine(Symbol), | |
26 | } | |
27 | ||
28 | pub type LevelSource = (Level, LintSource); | |
29 | ||
30 | pub struct LintLevelSets { | |
31 | pub list: Vec<LintSet>, | |
32 | pub lint_cap: Level, | |
33 | } | |
34 | ||
35 | pub enum LintSet { | |
36 | CommandLine { | |
37 | // -A,-W,-D flags, a `Symbol` for the flag itself and `Level` for which | |
38 | // flag. | |
39 | specs: FxHashMap<LintId, LevelSource>, | |
40 | }, | |
41 | ||
42 | Node { | |
43 | specs: FxHashMap<LintId, LevelSource>, | |
44 | parent: u32, | |
45 | }, | |
46 | } | |
47 | ||
48 | impl LintLevelSets { | |
49 | pub fn new() -> Self { | |
50 | LintLevelSets { list: Vec::new(), lint_cap: Level::Forbid } | |
51 | } | |
52 | ||
53 | pub fn get_lint_level( | |
54 | &self, | |
55 | lint: &'static Lint, | |
56 | idx: u32, | |
57 | aux: Option<&FxHashMap<LintId, LevelSource>>, | |
58 | sess: &Session, | |
59 | ) -> LevelSource { | |
60 | let (level, mut src) = self.get_lint_id_level(LintId::of(lint), idx, aux); | |
61 | ||
62 | // If `level` is none then we actually assume the default level for this | |
63 | // lint. | |
64 | let mut level = level.unwrap_or_else(|| lint.default_level(sess.edition())); | |
65 | ||
66 | // If we're about to issue a warning, check at the last minute for any | |
67 | // directives against the warnings "lint". If, for example, there's an | |
68 | // `allow(warnings)` in scope then we want to respect that instead. | |
69 | if level == Level::Warn { | |
70 | let (warnings_level, warnings_src) = | |
71 | self.get_lint_id_level(LintId::of(builtin::WARNINGS), idx, aux); | |
72 | if let Some(configured_warning_level) = warnings_level { | |
73 | if configured_warning_level != Level::Warn { | |
74 | level = configured_warning_level; | |
75 | src = warnings_src; | |
76 | } | |
77 | } | |
78 | } | |
79 | ||
80 | // Ensure that we never exceed the `--cap-lints` argument. | |
81 | level = cmp::min(level, self.lint_cap); | |
82 | ||
83 | if let Some(driver_level) = sess.driver_lint_caps.get(&LintId::of(lint)) { | |
84 | // Ensure that we never exceed driver level. | |
85 | level = cmp::min(*driver_level, level); | |
86 | } | |
87 | ||
88 | return (level, src); | |
89 | } | |
90 | ||
91 | pub fn get_lint_id_level( | |
92 | &self, | |
93 | id: LintId, | |
94 | mut idx: u32, | |
95 | aux: Option<&FxHashMap<LintId, LevelSource>>, | |
96 | ) -> (Option<Level>, LintSource) { | |
97 | if let Some(specs) = aux { | |
98 | if let Some(&(level, src)) = specs.get(&id) { | |
99 | return (Some(level), src); | |
100 | } | |
101 | } | |
102 | loop { | |
103 | match self.list[idx as usize] { | |
104 | LintSet::CommandLine { ref specs } => { | |
105 | if let Some(&(level, src)) = specs.get(&id) { | |
106 | return (Some(level), src); | |
107 | } | |
108 | return (None, LintSource::Default); | |
109 | } | |
110 | LintSet::Node { ref specs, parent } => { | |
111 | if let Some(&(level, src)) = specs.get(&id) { | |
112 | return (Some(level), src); | |
113 | } | |
114 | idx = parent; | |
115 | } | |
116 | } | |
117 | } | |
118 | } | |
119 | } | |
120 | ||
121 | pub struct LintLevelMap { | |
122 | pub sets: LintLevelSets, | |
123 | pub id_to_set: FxHashMap<HirId, u32>, | |
124 | } | |
125 | ||
126 | impl LintLevelMap { | |
127 | /// If the `id` was previously registered with `register_id` when building | |
128 | /// this `LintLevelMap` this returns the corresponding lint level and source | |
129 | /// of the lint level for the lint provided. | |
130 | /// | |
131 | /// If the `id` was not previously registered, returns `None`. If `None` is | |
132 | /// returned then the parent of `id` should be acquired and this function | |
133 | /// should be called again. | |
134 | pub fn level_and_source( | |
135 | &self, | |
136 | lint: &'static Lint, | |
137 | id: HirId, | |
138 | session: &Session, | |
139 | ) -> Option<LevelSource> { | |
140 | self.id_to_set.get(&id).map(|idx| self.sets.get_lint_level(lint, *idx, None, session)) | |
141 | } | |
142 | } | |
143 | ||
144 | impl<'a> HashStable<StableHashingContext<'a>> for LintLevelMap { | |
145 | #[inline] | |
146 | fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { | |
147 | let LintLevelMap { ref sets, ref id_to_set } = *self; | |
148 | ||
149 | id_to_set.hash_stable(hcx, hasher); | |
150 | ||
151 | let LintLevelSets { ref list, lint_cap } = *sets; | |
152 | ||
153 | lint_cap.hash_stable(hcx, hasher); | |
154 | ||
155 | hcx.while_hashing_spans(true, |hcx| { | |
156 | list.len().hash_stable(hcx, hasher); | |
157 | ||
158 | // We are working under the assumption here that the list of | |
159 | // lint-sets is built in a deterministic order. | |
160 | for lint_set in list { | |
161 | ::std::mem::discriminant(lint_set).hash_stable(hcx, hasher); | |
162 | ||
163 | match *lint_set { | |
164 | LintSet::CommandLine { ref specs } => { | |
165 | specs.hash_stable(hcx, hasher); | |
166 | } | |
167 | LintSet::Node { ref specs, parent } => { | |
168 | specs.hash_stable(hcx, hasher); | |
169 | parent.hash_stable(hcx, hasher); | |
170 | } | |
171 | } | |
172 | } | |
173 | }) | |
174 | } | |
175 | } | |
176 | ||
177 | pub fn struct_lint_level<'a>( | |
178 | sess: &'a Session, | |
179 | lint: &'static Lint, | |
180 | level: Level, | |
181 | src: LintSource, | |
182 | span: Option<MultiSpan>, | |
183 | msg: &str, | |
184 | ) -> DiagnosticBuilder<'a> { | |
185 | let mut err = match (level, span) { | |
186 | (Level::Allow, _) => return sess.diagnostic().struct_dummy(), | |
187 | (Level::Warn, Some(span)) => sess.struct_span_warn(span, msg), | |
188 | (Level::Warn, None) => sess.struct_warn(msg), | |
189 | (Level::Deny, Some(span)) | (Level::Forbid, Some(span)) => sess.struct_span_err(span, msg), | |
190 | (Level::Deny, None) | (Level::Forbid, None) => sess.struct_err(msg), | |
191 | }; | |
192 | ||
193 | // Check for future incompatibility lints and issue a stronger warning. | |
194 | let lint_id = LintId::of(lint); | |
195 | let future_incompatible = lint.future_incompatible; | |
196 | ||
197 | // If this code originates in a foreign macro, aka something that this crate | |
198 | // did not itself author, then it's likely that there's nothing this crate | |
199 | // can do about it. We probably want to skip the lint entirely. | |
200 | if err.span.primary_spans().iter().any(|s| in_external_macro(sess, *s)) { | |
201 | // Any suggestions made here are likely to be incorrect, so anything we | |
202 | // emit shouldn't be automatically fixed by rustfix. | |
203 | err.allow_suggestions(false); | |
204 | ||
205 | // If this is a future incompatible lint it'll become a hard error, so | |
206 | // we have to emit *something*. Also allow lints to whitelist themselves | |
207 | // on a case-by-case basis for emission in a foreign macro. | |
208 | if future_incompatible.is_none() && !lint.report_in_external_macro { | |
209 | err.cancel(); | |
210 | // Don't continue further, since we don't want to have | |
211 | // `diag_span_note_once` called for a diagnostic that isn't emitted. | |
212 | return err; | |
213 | } | |
214 | } | |
215 | ||
216 | let name = lint.name_lower(); | |
217 | match src { | |
218 | LintSource::Default => { | |
219 | sess.diag_note_once( | |
220 | &mut err, | |
221 | DiagnosticMessageId::from(lint), | |
222 | &format!("`#[{}({})]` on by default", level.as_str(), name), | |
223 | ); | |
224 | } | |
225 | LintSource::CommandLine(lint_flag_val) => { | |
226 | let flag = match level { | |
227 | Level::Warn => "-W", | |
228 | Level::Deny => "-D", | |
229 | Level::Forbid => "-F", | |
230 | Level::Allow => panic!(), | |
231 | }; | |
232 | let hyphen_case_lint_name = name.replace("_", "-"); | |
233 | if lint_flag_val.as_str() == name { | |
234 | sess.diag_note_once( | |
235 | &mut err, | |
236 | DiagnosticMessageId::from(lint), | |
237 | &format!( | |
238 | "requested on the command line with `{} {}`", | |
239 | flag, hyphen_case_lint_name | |
240 | ), | |
241 | ); | |
242 | } else { | |
243 | let hyphen_case_flag_val = lint_flag_val.as_str().replace("_", "-"); | |
244 | sess.diag_note_once( | |
245 | &mut err, | |
246 | DiagnosticMessageId::from(lint), | |
247 | &format!( | |
248 | "`{} {}` implied by `{} {}`", | |
249 | flag, hyphen_case_lint_name, flag, hyphen_case_flag_val | |
250 | ), | |
251 | ); | |
252 | } | |
253 | } | |
254 | LintSource::Node(lint_attr_name, src, reason) => { | |
255 | if let Some(rationale) = reason { | |
256 | err.note(&rationale.as_str()); | |
257 | } | |
258 | sess.diag_span_note_once( | |
259 | &mut err, | |
260 | DiagnosticMessageId::from(lint), | |
261 | src, | |
262 | "lint level defined here", | |
263 | ); | |
264 | if lint_attr_name.as_str() != name { | |
265 | let level_str = level.as_str(); | |
266 | sess.diag_note_once( | |
267 | &mut err, | |
268 | DiagnosticMessageId::from(lint), | |
269 | &format!( | |
270 | "`#[{}({})]` implied by `#[{}({})]`", | |
271 | level_str, name, level_str, lint_attr_name | |
272 | ), | |
273 | ); | |
274 | } | |
275 | } | |
276 | } | |
277 | ||
278 | err.code(DiagnosticId::Lint(name)); | |
279 | ||
280 | if let Some(future_incompatible) = future_incompatible { | |
281 | const STANDARD_MESSAGE: &str = "this was previously accepted by the compiler but is being phased out; \ | |
282 | it will become a hard error"; | |
283 | ||
284 | let explanation = if lint_id == LintId::of(builtin::UNSTABLE_NAME_COLLISIONS) { | |
285 | "once this method is added to the standard library, \ | |
286 | the ambiguity may cause an error or change in behavior!" | |
287 | .to_owned() | |
288 | } else if lint_id == LintId::of(builtin::MUTABLE_BORROW_RESERVATION_CONFLICT) { | |
289 | "this borrowing pattern was not meant to be accepted, \ | |
290 | and may become a hard error in the future" | |
291 | .to_owned() | |
292 | } else if let Some(edition) = future_incompatible.edition { | |
293 | format!("{} in the {} edition!", STANDARD_MESSAGE, edition) | |
294 | } else { | |
295 | format!("{} in a future release!", STANDARD_MESSAGE) | |
296 | }; | |
297 | let citation = format!("for more information, see {}", future_incompatible.reference); | |
298 | err.warn(&explanation); | |
299 | err.note(&citation); | |
300 | } | |
301 | ||
302 | return err; | |
303 | } | |
304 | ||
305 | /// Returns whether `span` originates in a foreign crate's external macro. | |
306 | /// | |
307 | /// This is used to test whether a lint should not even begin to figure out whether it should | |
308 | /// be reported on the current node. | |
309 | pub fn in_external_macro(sess: &Session, span: Span) -> bool { | |
310 | let expn_data = span.ctxt().outer_expn_data(); | |
311 | match expn_data.kind { | |
312 | ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false, | |
313 | ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external" | |
314 | ExpnKind::Macro(MacroKind::Bang, _) => { | |
315 | if expn_data.def_site.is_dummy() { | |
316 | // Dummy span for the `def_site` means it's an external macro. | |
317 | return true; | |
318 | } | |
319 | match sess.source_map().span_to_snippet(expn_data.def_site) { | |
320 | Ok(code) => !code.starts_with("macro_rules"), | |
321 | // No snippet means external macro or compiler-builtin expansion. | |
322 | Err(_) => true, | |
323 | } | |
324 | } | |
325 | ExpnKind::Macro(..) => true, // definitely a plugin | |
326 | } | |
327 | } | |
328 | ||
329 | pub fn add_elided_lifetime_in_path_suggestion( | |
330 | sess: &Session, | |
331 | db: &mut DiagnosticBuilder<'_>, | |
332 | n: usize, | |
333 | path_span: Span, | |
334 | incl_angl_brckt: bool, | |
335 | insertion_span: Span, | |
336 | anon_lts: String, | |
337 | ) { | |
338 | let (replace_span, suggestion) = if incl_angl_brckt { | |
339 | (insertion_span, anon_lts) | |
340 | } else { | |
341 | // When possible, prefer a suggestion that replaces the whole | |
342 | // `Path<T>` expression with `Path<'_, T>`, rather than inserting `'_, ` | |
343 | // at a point (which makes for an ugly/confusing label) | |
344 | if let Ok(snippet) = sess.source_map().span_to_snippet(path_span) { | |
345 | // But our spans can get out of whack due to macros; if the place we think | |
346 | // we want to insert `'_` isn't even within the path expression's span, we | |
347 | // should bail out of making any suggestion rather than panicking on a | |
348 | // subtract-with-overflow or string-slice-out-out-bounds (!) | |
349 | // FIXME: can we do better? | |
350 | if insertion_span.lo().0 < path_span.lo().0 { | |
351 | return; | |
352 | } | |
353 | let insertion_index = (insertion_span.lo().0 - path_span.lo().0) as usize; | |
354 | if insertion_index > snippet.len() { | |
355 | return; | |
356 | } | |
357 | let (before, after) = snippet.split_at(insertion_index); | |
358 | (path_span, format!("{}{}{}", before, anon_lts, after)) | |
359 | } else { | |
360 | (insertion_span, anon_lts) | |
361 | } | |
362 | }; | |
363 | db.span_suggestion( | |
364 | replace_span, | |
365 | &format!("indicate the anonymous lifetime{}", pluralize!(n)), | |
366 | suggestion, | |
367 | Applicability::MachineApplicable, | |
368 | ); | |
369 | } |