1use std::borrow::Cow;
2
3use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
4use rustc_errors::{
5 Applicability, Diag, DiagArgValue, LintDiagnostic, elided_lifetime_in_path_suggestion,
6};
7use rustc_middle::middle::stability;
8use rustc_middle::ty::TyCtxt;
9use rustc_session::Session;
10use rustc_session::lint::BuiltinLintDiag;
11use rustc_span::BytePos;
12use tracing::debug;
13
14use crate::lints;
15
16mod check_cfg;
17
18pub fn decorate_builtin_lint(
19 sess: &Session,
20 tcx: Option<TyCtxt<'_>>,
21 diagnostic: BuiltinLintDiag,
22 diag: &mut Diag<'_, ()>,
23) {
24 match diagnostic {
25 BuiltinLintDiag::UnicodeTextFlow(comment_span, content) => {
26 let spans: Vec<_> = content
27 .char_indices()
28 .filter_map(|(i, c)| {
29 TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
30 let lo = comment_span.lo() + BytePos(2 + i as u32);
31 (c, comment_span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
32 })
33 })
34 .collect();
35 let characters = spans
36 .iter()
37 .map(|&(c, span)| lints::UnicodeCharNoteSub { span, c_debug: format!("{c:?}") })
38 .collect();
39 let suggestions = (!spans.is_empty()).then_some(lints::UnicodeTextFlowSuggestion {
40 spans: spans.iter().map(|(_c, span)| *span).collect(),
41 });
42
43 lints::UnicodeTextFlow {
44 comment_span,
45 characters,
46 suggestions,
47 num_codepoints: spans.len(),
48 }
49 .decorate_lint(diag);
50 }
51 BuiltinLintDiag::AbsPathWithModule(mod_span) => {
52 let (replacement, applicability) = match sess.source_map().span_to_snippet(mod_span) {
53 Ok(ref s) => {
54 let opt_colon = if s.trim_start().starts_with("::") { "" } else { "::" };
57
58 (format!("crate{opt_colon}{s}"), Applicability::MachineApplicable)
59 }
60 Err(_) => ("crate::<path>".to_string(), Applicability::HasPlaceholders),
61 };
62 lints::AbsPathWithModule {
63 sugg: lints::AbsPathWithModuleSugg { span: mod_span, applicability, replacement },
64 }
65 .decorate_lint(diag);
66 }
67 BuiltinLintDiag::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident } => {
68 lints::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident }
69 .decorate_lint(diag)
70 }
71 BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => {
72 lints::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def }
73 .decorate_lint(diag)
74 }
75
76 BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => {
77 lints::ElidedLifetimesInPaths {
78 subdiag: elided_lifetime_in_path_suggestion(
79 sess.source_map(),
80 n,
81 path_span,
82 incl_angl_brckt,
83 insertion_span,
84 ),
85 }
86 .decorate_lint(diag);
87 }
88 BuiltinLintDiag::UnknownCrateTypes { span, candidate } => {
89 let sugg = candidate.map(|candidate| lints::UnknownCrateTypesSub { span, candidate });
90 lints::UnknownCrateTypes { sugg }.decorate_lint(diag);
91 }
92 BuiltinLintDiag::UnusedImports {
93 remove_whole_use,
94 num_to_remove,
95 remove_spans,
96 test_module_span,
97 span_snippets,
98 } => {
99 let sugg = if remove_whole_use {
100 lints::UnusedImportsSugg::RemoveWholeUse { span: remove_spans[0] }
101 } else {
102 lints::UnusedImportsSugg::RemoveImports { remove_spans, num_to_remove }
103 };
104 let test_module_span =
105 test_module_span.map(|span| sess.source_map().guess_head_span(span));
106
107 lints::UnusedImports {
108 sugg,
109 test_module_span,
110 num_snippets: span_snippets.len(),
111 span_snippets: DiagArgValue::StrListSepByAnd(
112 span_snippets.into_iter().map(Cow::Owned).collect(),
113 ),
114 }
115 .decorate_lint(diag);
116 }
117 BuiltinLintDiag::RedundantImport(spans, ident) => {
118 let subs = spans
119 .into_iter()
120 .map(|(span, is_imported)| {
121 (match (span.is_dummy(), is_imported) {
122 (false, true) => lints::RedundantImportSub::ImportedHere,
123 (false, false) => lints::RedundantImportSub::DefinedHere,
124 (true, true) => lints::RedundantImportSub::ImportedPrelude,
125 (true, false) => lints::RedundantImportSub::DefinedPrelude,
126 })(span)
127 })
128 .collect();
129 lints::RedundantImport { subs, ident }.decorate_lint(diag);
130 }
131 BuiltinLintDiag::DeprecatedMacro {
132 suggestion,
133 suggestion_span,
134 note,
135 path,
136 since_kind,
137 } => {
138 let sub = suggestion.map(|suggestion| stability::DeprecationSuggestion {
139 span: suggestion_span,
140 kind: "macro".to_owned(),
141 suggestion,
142 });
143
144 stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind }
145 .decorate_lint(diag);
146 }
147 BuiltinLintDiag::UnusedDocComment(attr_span) => {
148 lints::UnusedDocComment { span: attr_span }.decorate_lint(diag);
149 }
150 BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
151 let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };
152 if is_foreign {
153 lints::PatternsInFnsWithoutBody::Foreign { sub }
154 } else {
155 lints::PatternsInFnsWithoutBody::Bodiless { sub }
156 }
157 .decorate_lint(diag);
158 }
159 BuiltinLintDiag::MissingAbi(label_span, default_abi) => {
160 lints::MissingAbi { span: label_span, default_abi }.decorate_lint(diag);
161 }
162 BuiltinLintDiag::LegacyDeriveHelpers(label_span) => {
163 lints::LegacyDeriveHelpers { span: label_span }.decorate_lint(diag);
164 }
165 BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
166 lints::OrPatternsBackCompat { span: suggestion_span, suggestion }.decorate_lint(diag);
167 }
168 BuiltinLintDiag::ReservedPrefix(label_span, prefix) => {
169 lints::ReservedPrefix {
170 label: label_span,
171 suggestion: label_span.shrink_to_hi(),
172 prefix,
173 }
174 .decorate_lint(diag);
175 }
176 BuiltinLintDiag::RawPrefix(label_span) => {
177 lints::RawPrefix { label: label_span, suggestion: label_span.shrink_to_hi() }
178 .decorate_lint(diag);
179 }
180 BuiltinLintDiag::ReservedString { is_string, suggestion } => {
181 if is_string {
182 lints::ReservedString { suggestion }.decorate_lint(diag);
183 } else {
184 lints::ReservedMultihash { suggestion }.decorate_lint(diag);
185 }
186 }
187 BuiltinLintDiag::HiddenUnicodeCodepoints {
188 label,
189 count,
190 span_label,
191 labels,
192 escape,
193 spans,
194 } => {
195 lints::HiddenUnicodeCodepointsDiag {
196 label: &label,
197 count,
198 span_label,
199 labels: labels.map(|spans| lints::HiddenUnicodeCodepointsDiagLabels { spans }),
200 sub: if escape {
201 lints::HiddenUnicodeCodepointsDiagSub::Escape { spans }
202 } else {
203 lints::HiddenUnicodeCodepointsDiagSub::NoEscape { spans }
204 },
205 }
206 .decorate_lint(diag);
207 }
208 BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, macro_name, invoc_span } => {
209 lints::UnusedBuiltinAttribute { invoc_span, attr_name, macro_name }.decorate_lint(diag);
210 }
211 BuiltinLintDiag::TrailingMacro(is_trailing, name) => {
212 lints::TrailingMacro { is_trailing, name }.decorate_lint(diag);
213 }
214 BuiltinLintDiag::BreakWithLabelAndLoop(sugg_span) => {
215 lints::BreakWithLabelAndLoop {
216 sub: lints::BreakWithLabelAndLoopSub {
217 left: sugg_span.shrink_to_lo(),
218 right: sugg_span.shrink_to_hi(),
219 },
220 }
221 .decorate_lint(diag);
222 }
223 BuiltinLintDiag::UnexpectedCfgName(name, value) => {
224 check_cfg::unexpected_cfg_name(sess, tcx, name, value).decorate_lint(diag);
225 }
226 BuiltinLintDiag::UnexpectedCfgValue(name, value) => {
227 check_cfg::unexpected_cfg_value(sess, tcx, name, value).decorate_lint(diag);
228 }
229 BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
230 let suggestion = match sugg {
231 Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
232 left: left_sp,
233 right: right_sp,
234 sugg,
235 },
236 None => lints::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp },
237 };
238 lints::DeprecatedWhereClauseLocation { suggestion }.decorate_lint(diag);
239 }
240 BuiltinLintDiag::MissingUnsafeOnExtern { suggestion } => {
241 lints::MissingUnsafeOnExtern { suggestion }.decorate_lint(diag);
242 }
243 BuiltinLintDiag::SingleUseLifetime {
244 param_span,
245 use_span: Some((use_span, elide)),
246 deletion_span,
247 ident,
248 } => {
249 debug!(?param_span, ?use_span, ?deletion_span);
250 let suggestion = if let Some(deletion_span) = deletion_span {
251 let (use_span, replace_lt) = if elide {
252 let use_span = sess.source_map().span_extend_while_whitespace(use_span);
253 (use_span, String::new())
254 } else {
255 (use_span, "'_".to_owned())
256 };
257 debug!(?deletion_span, ?use_span);
258
259 let deletion_span =
262 if deletion_span.is_empty() { None } else { Some(deletion_span) };
263 Some(lints::SingleUseLifetimeSugg { deletion_span, use_span, replace_lt })
264 } else {
265 None
266 };
267
268 lints::SingleUseLifetime { suggestion, param_span, use_span, ident }
269 .decorate_lint(diag);
270 }
271 BuiltinLintDiag::SingleUseLifetime { use_span: None, deletion_span, ident, .. } => {
272 debug!(?deletion_span);
273 lints::UnusedLifetime { deletion_span, ident }.decorate_lint(diag);
274 }
275 BuiltinLintDiag::NamedArgumentUsedPositionally {
276 position_sp_to_replace,
277 position_sp_for_msg,
278 named_arg_sp,
279 named_arg_name,
280 is_formatting_arg,
281 } => {
282 let (suggestion, name) = if let Some(positional_arg_to_replace) = position_sp_to_replace
283 {
284 let mut name = named_arg_name.clone();
285 if is_formatting_arg {
286 name.push('$')
287 };
288 let span_to_replace = if let Ok(positional_arg_content) =
289 sess.source_map().span_to_snippet(positional_arg_to_replace)
290 && positional_arg_content.starts_with(':')
291 {
292 positional_arg_to_replace.shrink_to_lo()
293 } else {
294 positional_arg_to_replace
295 };
296 (Some(span_to_replace), name)
297 } else {
298 (None, String::new())
299 };
300
301 lints::NamedArgumentUsedPositionally {
302 named_arg_sp,
303 position_label_sp: position_sp_for_msg,
304 suggestion,
305 name,
306 named_arg_name,
307 }
308 .decorate_lint(diag);
309 }
310 BuiltinLintDiag::ByteSliceInPackedStructWithDerive { ty } => {
311 lints::ByteSliceInPackedStructWithDerive { ty }.decorate_lint(diag);
312 }
313 BuiltinLintDiag::UnusedExternCrate { span, removal_span } => {
314 lints::UnusedExternCrate { span, removal_span }.decorate_lint(diag);
315 }
316 BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => {
317 let suggestion_span = vis_span.between(ident_span);
318 let code = if vis_span.is_empty() { "use " } else { " use " };
319
320 lints::ExternCrateNotIdiomatic { span: suggestion_span, code }.decorate_lint(diag);
321 }
322 BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => {
323 lints::AmbiguousGlobImports { ambiguity }.decorate_lint(diag);
324 }
325 BuiltinLintDiag::AmbiguousGlobReexports {
326 name,
327 namespace,
328 first_reexport_span,
329 duplicate_reexport_span,
330 } => {
331 lints::AmbiguousGlobReexports {
332 first_reexport: first_reexport_span,
333 duplicate_reexport: duplicate_reexport_span,
334 name,
335 namespace,
336 }
337 .decorate_lint(diag);
338 }
339 BuiltinLintDiag::HiddenGlobReexports {
340 name,
341 namespace,
342 glob_reexport_span,
343 private_item_span,
344 } => {
345 lints::HiddenGlobReexports {
346 glob_reexport: glob_reexport_span,
347 private_item: private_item_span,
348
349 name,
350 namespace,
351 }
352 .decorate_lint(diag);
353 }
354 BuiltinLintDiag::UnusedQualifications { removal_span } => {
355 lints::UnusedQualifications { removal_span }.decorate_lint(diag);
356 }
357 BuiltinLintDiag::UnsafeAttrOutsideUnsafe {
358 attribute_name_span,
359 sugg_spans: (left, right),
360 } => {
361 lints::UnsafeAttrOutsideUnsafe {
362 span: attribute_name_span,
363 suggestion: lints::UnsafeAttrOutsideUnsafeSuggestion { left, right },
364 }
365 .decorate_lint(diag);
366 }
367 BuiltinLintDiag::AssociatedConstElidedLifetime {
368 elided,
369 span: lt_span,
370 lifetimes_in_scope,
371 } => {
372 let lt_span = if elided { lt_span.shrink_to_hi() } else { lt_span };
373 let code = if elided { "'static " } else { "'static" };
374 lints::AssociatedConstElidedLifetime {
375 span: lt_span,
376 code,
377 elided,
378 lifetimes_in_scope,
379 }
380 .decorate_lint(diag);
381 }
382 BuiltinLintDiag::RedundantImportVisibility { max_vis, span: vis_span, import_vis } => {
383 lints::RedundantImportVisibility { span: vis_span, help: (), max_vis, import_vis }
384 .decorate_lint(diag);
385 }
386 BuiltinLintDiag::UnknownDiagnosticAttribute { span: typo_span, typo_name } => {
387 let typo = typo_name.map(|typo_name| lints::UnknownDiagnosticAttributeTypoSugg {
388 span: typo_span,
389 typo_name,
390 });
391 lints::UnknownDiagnosticAttribute { typo }.decorate_lint(diag);
392 }
393 BuiltinLintDiag::MacroUseDeprecated => {
394 lints::MacroUseDeprecated.decorate_lint(diag);
395 }
396 BuiltinLintDiag::UnusedMacroUse => lints::UnusedMacroUse.decorate_lint(diag),
397 BuiltinLintDiag::PrivateExternCrateReexport { source: ident, extern_crate_span } => {
398 lints::PrivateExternCrateReexport { ident, sugg: extern_crate_span.shrink_to_lo() }
399 .decorate_lint(diag);
400 }
401 BuiltinLintDiag::UnusedLabel => lints::UnusedLabel.decorate_lint(diag),
402 BuiltinLintDiag::MacroIsPrivate(ident) => {
403 lints::MacroIsPrivate { ident }.decorate_lint(diag);
404 }
405 BuiltinLintDiag::UnusedMacroDefinition(name) => {
406 lints::UnusedMacroDefinition { name }.decorate_lint(diag);
407 }
408 BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
409 lints::MacroRuleNeverUsed { n: n + 1, name }.decorate_lint(diag);
410 }
411 BuiltinLintDiag::UnstableFeature(msg) => {
412 lints::UnstableFeature { msg }.decorate_lint(diag);
413 }
414 BuiltinLintDiag::AvoidUsingIntelSyntax => {
415 lints::AvoidIntelSyntax.decorate_lint(diag);
416 }
417 BuiltinLintDiag::AvoidUsingAttSyntax => {
418 lints::AvoidAttSyntax.decorate_lint(diag);
419 }
420 BuiltinLintDiag::IncompleteInclude => {
421 lints::IncompleteInclude.decorate_lint(diag);
422 }
423 BuiltinLintDiag::UnnameableTestItems => {
424 lints::UnnameableTestItems.decorate_lint(diag);
425 }
426 BuiltinLintDiag::DuplicateMacroAttribute => {
427 lints::DuplicateMacroAttribute.decorate_lint(diag);
428 }
429 BuiltinLintDiag::CfgAttrNoAttributes => {
430 lints::CfgAttrNoAttributes.decorate_lint(diag);
431 }
432 BuiltinLintDiag::MetaVariableStillRepeating(name) => {
433 lints::MetaVariableStillRepeating { name }.decorate_lint(diag);
434 }
435 BuiltinLintDiag::MetaVariableWrongOperator => {
436 lints::MetaVariableWrongOperator.decorate_lint(diag);
437 }
438 BuiltinLintDiag::DuplicateMatcherBinding => {
439 lints::DuplicateMatcherBinding.decorate_lint(diag);
440 }
441 BuiltinLintDiag::UnknownMacroVariable(name) => {
442 lints::UnknownMacroVariable { name }.decorate_lint(diag);
443 }
444 BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
445 lints::UnusedCrateDependency { extern_crate, local_crate }.decorate_lint(diag)
446 }
447 BuiltinLintDiag::IllFormedAttributeInput { suggestions } => {
448 lints::IllFormedAttributeInput {
449 num_suggestions: suggestions.len(),
450 suggestions: DiagArgValue::StrListSepByAnd(
451 suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
452 ),
453 }
454 .decorate_lint(diag)
455 }
456 BuiltinLintDiag::InnerAttributeUnstable { is_macro } => if is_macro {
457 lints::InnerAttributeUnstable::InnerMacroAttribute
458 } else {
459 lints::InnerAttributeUnstable::CustomInnerAttribute
460 }
461 .decorate_lint(diag),
462 BuiltinLintDiag::OutOfScopeMacroCalls { span, path, location } => {
463 lints::OutOfScopeMacroCalls { span, path, location }.decorate_lint(diag)
464 }
465 BuiltinLintDiag::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by } => {
466 lints::UnexpectedBuiltinCfg { cfg, cfg_name, controlled_by }.decorate_lint(diag)
467 }
468 }
469}