1use crate::LisetteDiagnostic;
2use syntax::ast::{DeadCodeCause, Span};
3
4#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5pub enum IssueKind {
6 RedundantLetElse,
7 RedundantIfLet,
8 UnreachableIfLetElse,
9 RedundantIfLetElse,
10}
11
12#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13pub enum UnusedExpressionKind {
14 Literal,
15 Result,
16 Option,
17 Partial,
18 Value,
19}
20
21impl UnusedExpressionKind {
22 pub fn lint_name(&self) -> &'static str {
23 match self {
24 Self::Literal => "unused_literal",
25 Self::Result => "unused_result",
26 Self::Option => "unused_option",
27 Self::Partial => "unused_partial",
28 Self::Value => "unused_value",
29 }
30 }
31}
32
33pub fn unused_variable(span: &Span, name: &str, is_struct_field: bool) -> LisetteDiagnostic {
34 let help = if is_struct_field {
35 format!(
36 "Use this variable or prefix it with an underscore: `{}: _{}`.",
37 name, name
38 )
39 } else {
40 format!(
41 "Use this variable or prefix it with an underscore: `_{}`.",
42 name
43 )
44 };
45 LisetteDiagnostic::warn("Unused variable")
46 .with_lint_code("unused_variable")
47 .with_span_label(span, "never used")
48 .with_help(help)
49}
50
51pub fn unused_parameter(span: &Span, name: &str) -> LisetteDiagnostic {
52 LisetteDiagnostic::warn("Unused parameter")
53 .with_lint_code("unused_param")
54 .with_span_label(span, "never used")
55 .with_help(format!(
56 "Use this parameter or prefix it with an underscore: `_{}`.",
57 name
58 ))
59}
60
61pub fn unused_mut(span: &Span) -> LisetteDiagnostic {
62 LisetteDiagnostic::warn("Unused `mut`")
63 .with_lint_code("unnecessary_mut")
64 .with_span_label(span, "declared as mutable")
65 .with_help("Remove `mut` from the declaration if you do not need to mutate the variable")
66}
67
68pub fn written_but_not_read(span: &Span, name: &str) -> LisetteDiagnostic {
69 LisetteDiagnostic::warn("Variable assigned but never read")
70 .with_lint_code("assigned_but_never_read")
71 .with_span_label(span, format!("`{}` is assigned but never read", name))
72 .with_help(
73 "Read the variable after assigning it, or explicitly discard it with `let _ = ...`",
74 )
75}
76
77pub fn dead_code(span: &Span, cause: DeadCodeCause) -> LisetteDiagnostic {
78 let (code, msg) = match cause {
79 DeadCodeCause::Return => ("dead_code_after_return", "Unreachable code after return"),
80 DeadCodeCause::Break => ("dead_code_after_break", "Unreachable code after break"),
81 DeadCodeCause::Continue => (
82 "dead_code_after_continue",
83 "Unreachable code after continue",
84 ),
85 DeadCodeCause::DivergingIf => (
86 "dead_code_after_diverging_if",
87 "Unreachable code after diverging if/else",
88 ),
89 DeadCodeCause::DivergingMatch => (
90 "dead_code_after_diverging_match",
91 "Unreachable code after diverging match",
92 ),
93 DeadCodeCause::InfiniteLoop => (
94 "dead_code_after_infinite_loop",
95 "Unreachable code after infinite loop",
96 ),
97 DeadCodeCause::DivergingCall => (
98 "dead_code_after_diverging_call",
99 "Unreachable code after diverging function call",
100 ),
101 };
102 LisetteDiagnostic::warn(msg)
103 .with_lint_code(code)
104 .with_span_label(span, "unreachable from this point onward")
105 .with_help("Remove this line and all code after it")
106}
107
108pub fn pattern_issue(span: &Span, kind: IssueKind) -> LisetteDiagnostic {
109 let (code, message, label, help) = match kind {
110 IssueKind::RedundantLetElse => (
111 "redundant_let_else",
112 "Redundant `else` in `let...else`",
113 "always matches",
114 "Remove the `else` block since the pattern cannot fail",
115 ),
116 IssueKind::RedundantIfLet => (
117 "redundant_if_let",
118 "Redundant `if let` pattern",
119 "always matches",
120 "Use `let` instead of `if let` since the pattern cannot fail",
121 ),
122 IssueKind::UnreachableIfLetElse => (
123 "unreachable_if_let_else",
124 "Unreachable `else` branch",
125 "this branch can never execute",
126 "Remove the `else` branch since the pattern always matches",
127 ),
128 IssueKind::RedundantIfLetElse => (
129 "redundant_if_let_else",
130 "Redundant `else` branch",
131 "this branch does nothing",
132 "Remove the `else` branch",
133 ),
134 };
135
136 LisetteDiagnostic::warn(message)
137 .with_lint_code(code)
138 .with_span_label(span, label)
139 .with_help(help)
140}
141
142pub fn unused_expression(span: &Span, kind: UnusedExpressionKind) -> LisetteDiagnostic {
143 let (code, msg, label, help) = match kind {
144 UnusedExpressionKind::Literal => (
145 "unused_literal",
146 "Unused literal",
147 "this literal has no effect",
148 "Remove this literal",
149 ),
150 UnusedExpressionKind::Result => (
151 "unused_result",
152 "`Result` is silently discarded",
153 "failure will go unnoticed",
154 "Handle this `Result` with `?` or `match`, or explicitly discard it with `let _ = ...`",
155 ),
156 UnusedExpressionKind::Option => (
157 "unused_option",
158 "Unused Option",
159 "this `Option` is discarded",
160 "Handle this `Option`, or explicitly discard it with `let _ = ...`",
161 ),
162 UnusedExpressionKind::Partial => (
163 "unused_partial",
164 "`Partial` is silently discarded",
165 "partial result will go unnoticed",
166 "Handle this `Partial` with `match`, or explicitly discard it with `let _ = ...`",
167 ),
168 UnusedExpressionKind::Value => (
169 "unused_value",
170 "Unused expression value",
171 "this value is discarded",
172 "Use the value, or ignore with `let _ = ...`",
173 ),
174 };
175 LisetteDiagnostic::warn(msg)
176 .with_lint_code(code)
177 .with_span_label(span, label)
178 .with_help(help)
179}
180
181pub fn unnecessary_reference(span: &Span, name: Option<&str>) -> LisetteDiagnostic {
182 let (label, help) = match name {
183 Some(n) => (
184 format!("`{}` is already a reference", n),
185 format!("Remove the `&` operator from `{}`", n),
186 ),
187 None => (
188 "value is already a reference".to_string(),
189 "Remove the `&` operator".to_string(),
190 ),
191 };
192 LisetteDiagnostic::warn("Unnecessary `&`")
193 .with_lint_code("unnecessary_reference")
194 .with_span_label(span, label)
195 .with_help(help)
196}
197
198pub fn unused_type_parameter(span: &Span) -> LisetteDiagnostic {
199 LisetteDiagnostic::warn("Unused type parameter")
200 .with_lint_code("unused_type_param")
201 .with_span_label(span, "never used")
202 .with_help("Remove the unused type parameter or use it in the signature")
203}
204
205pub fn type_param_only_in_bound(span: &Span, name: &str) -> LisetteDiagnostic {
206 LisetteDiagnostic::warn("Type parameter only used in bound")
207 .with_lint_code("type_param_only_in_bound")
208 .with_span_label(
209 span,
210 format!("`{}` is only used inside another parameter's bound", name),
211 )
212 .with_help("Remove it, or use it in a parameter type, return type, or bound left-hand side")
213}
214
215pub fn ineffective_try_block(span: &Span) -> LisetteDiagnostic {
216 LisetteDiagnostic::warn("Ineffective `try` block")
217 .with_lint_code("try_block_no_success_path")
218 .with_span_label(span, "always propagates")
219 .with_help("A `try` block is effective only if the expression may succeed or fail")
220}
221
222pub fn replaceable_with_zero_fill(span: &Span, kept: &str, struct_name: &str) -> LisetteDiagnostic {
223 let example = if kept.is_empty() {
224 format!("`{} {{ .. }}`", struct_name)
225 } else {
226 format!("`{} {{ {}, .. }}`", struct_name, kept)
227 };
228 LisetteDiagnostic::warn("Replaceable with zero-fill spread")
229 .with_lint_code("replaceable_with_zero_fill")
230 .with_span_label(span, "has zero-valued fields")
231 .with_help(format!(
232 "Replace zero-valued fields with zero-fill spread: {}",
233 example
234 ))
235}
236
237pub fn double_negation(span: &Span, is_bool: bool) -> LisetteDiagnostic {
238 let (code, msg) = if is_bool {
239 ("double_bool_negation", "Double boolean negation")
240 } else {
241 ("double_int_negation", "Double numeric negation")
242 };
243
244 LisetteDiagnostic::warn(msg)
245 .with_lint_code(code)
246 .with_span_label(span, "accidental double negation")
247 .with_help("Remove one of the negation operators")
248}
249
250pub fn tautological_comparison(span: &Span, always_true: bool) -> LisetteDiagnostic {
251 let result = if always_true { "true" } else { "false" };
252
253 LisetteDiagnostic::warn("Tautological comparison")
254 .with_lint_code("self_comparison")
255 .with_span_label(span, "comparing to itself")
256 .with_help(format!(
257 "This condition is always {}. Did you mean to compare different values?",
258 result
259 ))
260}
261
262pub fn self_assignment(span: &Span) -> LisetteDiagnostic {
263 LisetteDiagnostic::warn("Self-assignment")
264 .with_lint_code("self_assignment")
265 .with_span_label(span, "assigning to itself")
266 .with_help("Correct this assignment")
267}
268
269pub fn duplicate_logical_operand(span: &Span, operand_text: &str) -> LisetteDiagnostic {
270 LisetteDiagnostic::warn("Duplicate logical operand")
271 .with_lint_code("duplicate_logical_operand")
272 .with_span_label(span, "accidental repetition")
273 .with_help(format!("Simplify to `{operand_text}`"))
274}
275
276pub fn bool_literal_comparison(span: &Span, replacement: &str) -> LisetteDiagnostic {
277 LisetteDiagnostic::warn("Redundant comparison to boolean literal")
278 .with_lint_code("bool_literal_comparison")
279 .with_span_label(span, "needlessly verbose")
280 .with_help(format!("Simplify to `{replacement}`"))
281}
282
283pub fn identical_if_branches(span: &Span) -> LisetteDiagnostic {
284 LisetteDiagnostic::warn("Identical if-else branches")
285 .with_lint_code("identical_if_branches")
286 .with_span_label(span, "both branches are equivalent")
287 .with_help("Remove the `if` and keep a single copy of the branch body")
288}
289
290pub fn empty_match_arm(span: &Span) -> LisetteDiagnostic {
291 LisetteDiagnostic::warn("Empty match arm")
292 .with_lint_code("empty_match_arm")
293 .with_span_label(span, "forgotten stub?")
294 .with_help("Return `()` to indicate an intentional no-op in a match arm")
295}
296
297pub fn unnecessary_parens(span: &Span, keyword: &str) -> LisetteDiagnostic {
298 LisetteDiagnostic::warn("Unnecessary parens")
299 .with_lint_code("excess_parens_on_condition")
300 .with_span_label(span, "remove parens")
301 .with_help(format!(
302 "Lisette does not require parens around `{}` conditions",
303 keyword
304 ))
305}
306
307pub fn match_on_literal(span: &Span) -> LisetteDiagnostic {
308 LisetteDiagnostic::warn("Ineffective match")
309 .with_lint_code("match_on_literal")
310 .with_span_label(span, "already known")
311 .with_help(
312 "Matching on a literal is ineffective, because this always succeeds. Did you mean to match on a variable?",
313 )
314}
315
316pub fn single_arm_match(span: &Span, pattern_suggestion: &str) -> LisetteDiagnostic {
317 LisetteDiagnostic::warn("Ineffective match")
318 .with_lint_code("single_arm_match")
319 .with_span_label(span, "should be `if let`")
320 .with_help(format!(
321 "A match with a single meaningful arm is ineffective. Use `if let {} = value {{ ... }}` instead.",
322 pattern_suggestion
323 ))
324}
325
326pub fn uninterpolated_fstring(span: &Span) -> LisetteDiagnostic {
327 LisetteDiagnostic::warn("Uninterpolated f-string")
328 .with_lint_code("uninterpolated_fstring")
329 .with_span_label(span, "zero interpolations")
330 .with_help("Remove the `f` prefix. A string without interpolations does not need to be a format string")
331}
332
333pub fn unnecessary_raw_string(span: &Span) -> LisetteDiagnostic {
334 LisetteDiagnostic::warn("Unnecessary raw string")
335 .with_lint_code("unnecessary_raw_string")
336 .with_span_label(span, "no backslashes")
337 .with_help("Remove the `r` prefix. A string without backslashes does not need to be raw")
338}
339
340pub fn expression_only_fstring(span: &Span) -> LisetteDiagnostic {
341 LisetteDiagnostic::warn("Expression-only f-string")
342 .with_lint_code("expression_only_fstring")
343 .with_span_label(span, "the entire f-string is an expression")
344 .with_help("Use the expression directly. Wrapping it in an f-string adds no value")
345}
346
347pub fn rest_only_slice_pattern(span: &Span, help: impl Into<String>) -> LisetteDiagnostic {
348 LisetteDiagnostic::warn("Ineffective pattern")
349 .with_lint_code("rest_only_slice_pattern")
350 .with_span_label(span, "always matches")
351 .with_help(help)
352}
353
354pub fn miscased_pascal(span: &Span, code: &str, suggested_name: &str) -> LisetteDiagnostic {
355 LisetteDiagnostic::warn("Miscased name")
356 .with_lint_code(code)
357 .with_span_label(span, "expected PascalCase")
358 .with_help(format!("Rename to `{}`", suggested_name))
359}
360
361pub fn miscased_snake(span: &Span, code: &str, suggested_name: &str) -> LisetteDiagnostic {
362 LisetteDiagnostic::warn("Miscased name")
363 .with_lint_code(code)
364 .with_span_label(span, "expected snake_case")
365 .with_help(format!("Rename to `{}`", suggested_name))
366}
367
368pub fn miscased_screaming_snake(span: &Span, suggested_name: &str) -> LisetteDiagnostic {
369 LisetteDiagnostic::error("Miscased name")
370 .with_infer_code("constant_not_screaming_snake_case")
371 .with_span_label(span, "expected SCREAMING_SNAKE_CASE")
372 .with_help(format!("Rename to `{}`", suggested_name))
373}
374
375pub fn unused_field(span: &Span) -> LisetteDiagnostic {
376 LisetteDiagnostic::warn("Unused field")
377 .with_lint_code("unused_struct_field")
378 .with_span_label(span, "never read")
379 .with_help("Use or remove this field")
380}
381
382pub fn unused_variant(span: &Span) -> LisetteDiagnostic {
383 LisetteDiagnostic::warn("Unused variant")
384 .with_lint_code("unused_enum_variant")
385 .with_span_label(span, "never constructed or matched")
386 .with_help("Use or remove this enum variant")
387}
388
389pub fn unused_import(span: &Span) -> LisetteDiagnostic {
390 LisetteDiagnostic::warn("Unused import")
391 .with_lint_code("unused_import")
392 .with_span_label(span, "never used")
393 .with_help("Use or remove this import")
394}
395
396pub fn unused_type(span: &Span) -> LisetteDiagnostic {
397 LisetteDiagnostic::warn("Unused type")
398 .with_lint_code("unused_type")
399 .with_span_label(span, "never used")
400 .with_help("Use or remove this type")
401}
402
403pub fn unused_function(span: &Span) -> LisetteDiagnostic {
404 LisetteDiagnostic::warn("Unused function")
405 .with_lint_code("unused_function")
406 .with_span_label(span, "never called")
407 .with_help("Call or remove this function")
408}
409
410pub fn unused_constant(span: &Span) -> LisetteDiagnostic {
411 LisetteDiagnostic::warn("Unused constant")
412 .with_lint_code("unused_constant")
413 .with_span_label(span, "never used")
414 .with_help("Use or remove this constant")
415}
416
417pub fn private_type_in_public_api(
418 span: Option<&Span>,
419 private_type: &str,
420 public_definition: &str,
421) -> LisetteDiagnostic {
422 let mut diagnostic = LisetteDiagnostic::warn(format!(
423 "Private type `{}` in public API",
424 private_type
425 ))
426 .with_lint_code("internal_type_leak")
427 .with_help(format!(
428 "`{}` is private but exposed by `{}`, which is public. Add `pub` to the private type or remove it from the public API",
429 private_type, public_definition
430 ));
431
432 if let Some(s) = span {
433 diagnostic = diagnostic.with_span_label(s, "private");
434 }
435
436 diagnostic
437}
438
439pub fn unknown_attribute(span: &Span, name: &str) -> LisetteDiagnostic {
440 LisetteDiagnostic::warn("Unknown attribute")
441 .with_lint_code("unknown_attribute")
442 .with_span_label(span, "not recognized")
443 .with_help(format!(
444 "`{}` is not a recognized attribute. Known attributes: `#[json]`, `#[xml]`, `#[yaml]`, `#[toml]`, `#[db]`, `#[bson]`, `#[msgpack]`, `#[mapstructure]`, `#[tag]`",
445 name
446 ))
447}
448
449pub fn tag_has_alias(span: &Span, key: &str) -> LisetteDiagnostic {
450 LisetteDiagnostic::warn("Prefer predefined tag alias")
451 .with_lint_code("tag_has_alias")
452 .with_span_label(span, "use alias instead")
453 .with_help(format!(
454 "Use `#[{}(...)]` instead of `#[tag(...)]` for better validation",
455 key
456 ))
457}
458
459pub fn unknown_tag_option(span: &Span, option: &str) -> LisetteDiagnostic {
460 LisetteDiagnostic::warn("Unknown tag option")
461 .with_lint_code("unknown_tag_option")
462 .with_span_label(span, "not recognized")
463 .with_help(format!(
464 "`{}` is not a recognized tag option. Known options: `snake_case`, `camel_case`, `omitempty`, `!omitempty`, `skip`, `string`",
465 option
466 ))
467}