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::info(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::info("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::info("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 unsigned_comparison(span: &Span, always_true: bool) -> LisetteDiagnostic {
263 let result = if always_true { "true" } else { "false" };
264
265 LisetteDiagnostic::warn(format!("Comparison is always {result}"))
266 .with_lint_code("unsigned_comparison")
267 .with_span_label(span, format!("always {result}"))
268 .with_help(
269 "An unsigned integer is never negative, so this comparison always has the same result. Did you mean to compare against a different value?",
270 )
271}
272
273pub fn verbose_failure_propagation(span: &Span) -> LisetteDiagnostic {
274 LisetteDiagnostic::info("Verbose failure propagation")
275 .with_lint_code("verbose_failure_propagation")
276 .with_span_label(span, "verbose")
277 .with_help("Use `?` to propagate the failure concisely")
278}
279
280pub fn self_assignment(span: &Span) -> LisetteDiagnostic {
281 LisetteDiagnostic::warn("Self-assignment")
282 .with_lint_code("self_assignment")
283 .with_span_label(span, "assigning to itself")
284 .with_help("Correct this assignment")
285}
286
287pub fn manual_compound_assignment(span: &Span, symbol: &str) -> LisetteDiagnostic {
288 LisetteDiagnostic::info("Manual compound assignment")
289 .with_lint_code("manual_compound_assignment")
290 .with_span_label(span, "can be simpler")
291 .with_help(format!("Use the `{symbol}` compound assignment operator"))
292}
293
294pub fn manual_is_empty(span: &Span, replacement: &str) -> LisetteDiagnostic {
295 LisetteDiagnostic::info("Length comparison can use `is_empty()`")
296 .with_lint_code("manual_is_empty")
297 .with_span_label(span, "can be simpler")
298 .with_help(format!("Simplify to `{replacement}`"))
299}
300
301pub fn duplicate_logical_operand(span: &Span, operand_text: &str) -> LisetteDiagnostic {
302 LisetteDiagnostic::warn("Duplicate logical operand")
303 .with_lint_code("duplicate_logical_operand")
304 .with_span_label(span, "accidental repetition")
305 .with_help(format!("Simplify to `{operand_text}`"))
306}
307
308pub fn bool_literal_comparison(span: &Span, replacement: &str) -> LisetteDiagnostic {
309 LisetteDiagnostic::info("Redundant comparison to boolean literal")
310 .with_lint_code("bool_literal_comparison")
311 .with_span_label(span, "can be simpler")
312 .with_help(format!("Simplify to `{replacement}`"))
313}
314
315pub fn loop_runs_once(span: &Span) -> LisetteDiagnostic {
316 LisetteDiagnostic::warn("Loop runs at most once")
317 .with_lint_code("loop_runs_once")
318 .with_span_label(span, "the body always exits before looping back")
319 .with_help(
320 "The body always exits on the first iteration, so the loop never repeats. Make the exit conditional, or remove the loop.",
321 )
322}
323
324pub fn unnecessary_return(span: &Span) -> LisetteDiagnostic {
325 LisetteDiagnostic::info("Unnecessary `return`")
326 .with_lint_code("unnecessary_return")
327 .with_span_label(span, "redundant in tail position")
328 .with_help("The final expression of a function is its return value. Drop `return` and keep the value")
329}
330
331pub fn identical_if_branches(span: &Span) -> LisetteDiagnostic {
332 LisetteDiagnostic::warn("Identical if-else branches")
333 .with_lint_code("identical_if_branches")
334 .with_span_label(span, "both branches are equivalent")
335 .with_help("Remove the `if` and keep a single copy of the branch body")
336}
337
338pub fn identical_match_arms(span: &Span) -> LisetteDiagnostic {
339 LisetteDiagnostic::warn("Identical match arms")
340 .with_lint_code("identical_match_arms")
341 .with_span_label(span, "every arm is identical")
342 .with_help(
343 "All `match` arms resolve to the same value. Did you mean for the arms to differ?",
344 )
345}
346
347pub fn unnecessary_bool(span: &Span, consequence_is_true: bool) -> LisetteDiagnostic {
348 let help = if consequence_is_true {
349 "Replace this `if... else` with the condition itself"
350 } else {
351 "Replace this `if... else` with the negated condition"
352 };
353
354 LisetteDiagnostic::info("Unnecessary boolean if-else")
355 .with_lint_code("unnecessary_bool")
356 .with_span_label(span, "can be simpler")
357 .with_help(help)
358}
359
360pub fn redundant_pattern_matching(span: &Span, predicate: &str) -> LisetteDiagnostic {
361 LisetteDiagnostic::info("Redundant pattern matching")
362 .with_lint_code("redundant_pattern_matching")
363 .with_span_label(span, "can be simpler")
364 .with_help(format!("Replace this `match` with `.{predicate}()`"))
365}
366
367pub fn manual_map(span: &Span) -> LisetteDiagnostic {
368 LisetteDiagnostic::info("Manual map")
369 .with_lint_code("manual_map")
370 .with_span_label(span, "can be simpler")
371 .with_help("Replace this `match` with `.map(...)`")
372}
373
374pub fn manual_unwrap_or(span: &Span, default_has_effects: bool) -> LisetteDiagnostic {
375 let method = if default_has_effects {
376 "unwrap_or_else"
377 } else {
378 "unwrap_or"
379 };
380 LisetteDiagnostic::info("Manual `unwrap_or`")
381 .with_lint_code("manual_unwrap_or")
382 .with_span_label(span, "can be simpler")
383 .with_help(format!("Replace this `match` with `.{method}(...)`"))
384}
385
386pub fn redundant_closure(span: &Span, callee: &str) -> LisetteDiagnostic {
387 LisetteDiagnostic::info("Redundant closure")
388 .with_lint_code("redundant_closure")
389 .with_span_label(span, "can be simpler")
390 .with_help(format!("Replace this closure with `{callee}`"))
391}
392
393pub fn empty_match_arm(span: &Span) -> LisetteDiagnostic {
394 LisetteDiagnostic::warn("Empty match arm")
395 .with_lint_code("empty_match_arm")
396 .with_span_label(span, "forgotten stub?")
397 .with_help("Return `()` to indicate an intentional no-op in a match arm")
398}
399
400pub fn unnecessary_parens(span: &Span, keyword: &str) -> LisetteDiagnostic {
401 LisetteDiagnostic::info("Unnecessary parens")
402 .with_lint_code("excess_parens_on_condition")
403 .with_span_label(span, "remove parens")
404 .with_help(format!(
405 "Lisette does not require parens around `{}` conditions",
406 keyword
407 ))
408}
409
410pub fn match_on_literal(span: &Span) -> LisetteDiagnostic {
411 LisetteDiagnostic::warn("Ineffective match")
412 .with_lint_code("match_on_literal")
413 .with_span_label(span, "already known")
414 .with_help(
415 "Matching on a literal is ineffective, because this always succeeds. Did you mean to match on a variable?",
416 )
417}
418
419pub fn single_arm_match(span: &Span, pattern_suggestion: &str) -> LisetteDiagnostic {
420 LisetteDiagnostic::info("Ineffective match")
421 .with_lint_code("single_arm_match")
422 .with_span_label(span, "should be `if let`")
423 .with_help(format!(
424 "A match with a single meaningful arm is ineffective. Use `if let {} = value {{ ... }}` instead.",
425 pattern_suggestion
426 ))
427}
428
429pub fn uninterpolated_fstring(span: &Span) -> LisetteDiagnostic {
430 LisetteDiagnostic::info("Uninterpolated f-string")
431 .with_lint_code("uninterpolated_fstring")
432 .with_span_label(span, "zero interpolations")
433 .with_help("Remove the `f` prefix. A string without interpolations does not need to be a format string")
434}
435
436pub fn unnecessary_raw_string(span: &Span) -> LisetteDiagnostic {
437 LisetteDiagnostic::info("Unnecessary raw string")
438 .with_lint_code("unnecessary_raw_string")
439 .with_span_label(span, "no backslashes")
440 .with_help("Remove the `r` prefix. A string without backslashes does not need to be raw")
441}
442
443pub fn invisible_in_string(
444 span: &Span,
445 codepoint: u32,
446 name: &str,
447 is_bidi: bool,
448) -> LisetteDiagnostic {
449 let (title, code, help) = if is_bidi {
450 (
451 "Bidirectional character in string",
452 "bidi_in_string",
453 "Bidirectional control characters can reorder surrounding text and enable source-spoofing attacks. If intentional, write it as a `\\u` escape so it is visible in source; otherwise remove it.",
454 )
455 } else {
456 (
457 "Invisible character in string",
458 "invisible_in_string",
459 "Invisible characters in strings can hide bugs and silently shift meaning. Remove the character, or replace it with the visible character you meant.",
460 )
461 };
462 LisetteDiagnostic::warn(title)
463 .with_lint_code(code)
464 .with_span_label(span, format!("contains U+{codepoint:04X} ({name})"))
465 .with_help(help)
466}
467
468pub fn expression_only_fstring(span: &Span) -> LisetteDiagnostic {
469 LisetteDiagnostic::info("Expression-only f-string")
470 .with_lint_code("expression_only_fstring")
471 .with_span_label(span, "the entire f-string is an expression")
472 .with_help("Use the expression directly. Wrapping it in an f-string adds no value")
473}
474
475pub fn rest_only_slice_pattern(span: &Span, help: impl Into<String>) -> LisetteDiagnostic {
476 LisetteDiagnostic::info("Ineffective pattern")
477 .with_lint_code("rest_only_slice_pattern")
478 .with_span_label(span, "always matches")
479 .with_help(help)
480}
481
482pub fn miscased_pascal(span: &Span, code: &str, suggested_name: &str) -> LisetteDiagnostic {
483 LisetteDiagnostic::warn("Miscased name")
484 .with_lint_code(code)
485 .with_span_label(span, "expected PascalCase")
486 .with_help(format!("Rename to `{}`", suggested_name))
487}
488
489pub fn miscased_snake(span: &Span, code: &str, suggested_name: &str) -> LisetteDiagnostic {
490 LisetteDiagnostic::warn("Miscased name")
491 .with_lint_code(code)
492 .with_span_label(span, "expected snake_case")
493 .with_help(format!("Rename to `{}`", suggested_name))
494}
495
496pub fn miscased_screaming_snake(span: &Span, suggested_name: &str) -> LisetteDiagnostic {
497 LisetteDiagnostic::error("Miscased name")
498 .with_infer_code("constant_not_screaming_snake_case")
499 .with_span_label(span, "expected SCREAMING_SNAKE_CASE")
500 .with_help(format!("Rename to `{}`", suggested_name))
501}
502
503pub fn unused_field(span: &Span) -> LisetteDiagnostic {
504 LisetteDiagnostic::warn("Unused field")
505 .with_lint_code("unused_struct_field")
506 .with_span_label(span, "never read")
507 .with_help("Use or remove this field")
508}
509
510pub fn unused_variant(span: &Span) -> LisetteDiagnostic {
511 LisetteDiagnostic::warn("Unused variant")
512 .with_lint_code("unused_enum_variant")
513 .with_span_label(span, "never constructed or matched")
514 .with_help("Use or remove this enum variant")
515}
516
517pub fn unused_import(span: &Span) -> LisetteDiagnostic {
518 LisetteDiagnostic::warn("Unused import")
519 .with_lint_code("unused_import")
520 .with_span_label(span, "never used")
521 .with_help("Use or remove this import")
522}
523
524pub fn unused_type(span: &Span) -> LisetteDiagnostic {
525 LisetteDiagnostic::warn("Unused type")
526 .with_lint_code("unused_type")
527 .with_span_label(span, "never used")
528 .with_help("Use or remove this type")
529}
530
531pub fn unused_function(span: &Span) -> LisetteDiagnostic {
532 LisetteDiagnostic::warn("Unused function")
533 .with_lint_code("unused_function")
534 .with_span_label(span, "never called")
535 .with_help("Call or remove this function")
536}
537
538pub fn unused_constant(span: &Span) -> LisetteDiagnostic {
539 LisetteDiagnostic::warn("Unused constant")
540 .with_lint_code("unused_constant")
541 .with_span_label(span, "never used")
542 .with_help("Use or remove this constant")
543}
544
545pub fn private_type_in_public_api(
546 span: Option<&Span>,
547 private_type: &str,
548 public_definition: &str,
549) -> LisetteDiagnostic {
550 let mut diagnostic = LisetteDiagnostic::warn(format!(
551 "Private type `{}` in public API",
552 private_type
553 ))
554 .with_lint_code("internal_type_leak")
555 .with_help(format!(
556 "`{}` is private but exposed by `{}`, which is public. Add `pub` to the private type or remove it from the public API",
557 private_type, public_definition
558 ));
559
560 if let Some(s) = span {
561 diagnostic = diagnostic.with_span_label(s, "private");
562 }
563
564 diagnostic
565}
566
567pub fn unknown_attribute(span: &Span, name: &str) -> LisetteDiagnostic {
568 LisetteDiagnostic::warn("Unknown attribute")
569 .with_lint_code("unknown_attribute")
570 .with_span_label(span, "not recognized")
571 .with_help(format!(
572 "`{}` is not a recognized attribute. Known attributes: `#[json]`, `#[xml]`, `#[yaml]`, `#[toml]`, `#[db]`, `#[bson]`, `#[msgpack]`, `#[mapstructure]`, `#[tag]`",
573 name
574 ))
575}
576
577pub fn tag_has_alias(span: &Span, key: &str) -> LisetteDiagnostic {
578 LisetteDiagnostic::info("Prefer predefined tag alias")
579 .with_lint_code("tag_has_alias")
580 .with_span_label(span, "use alias instead")
581 .with_help(format!(
582 "Use `#[{}(...)]` instead of `#[tag(...)]` for better validation",
583 key
584 ))
585}
586
587pub fn unknown_tag_option(span: &Span, option: &str) -> LisetteDiagnostic {
588 LisetteDiagnostic::warn("Unknown tag option")
589 .with_lint_code("unknown_tag_option")
590 .with_span_label(span, "not recognized")
591 .with_help(format!(
592 "`{}` is not a recognized tag option. Known options: `snake_case`, `camel_case`, `omitempty`, `!omitempty`, `skip`, `string`",
593 option
594 ))
595}
596
597pub fn trim_charset_misuse(span: &Span, function: &str) -> LisetteDiagnostic {
598 LisetteDiagnostic::warn(format!("Misuse of `{function}`"))
599 .with_lint_code("trim_charset_misuse")
600 .with_span_label(span, "treated as charset")
601 .with_help(format!(
602 "`strings.{function}` removes a set of characters, not a substring. Did you mean `strings.TrimPrefix` or `strings.TrimSuffix`?"
603 ))
604}
605
606pub fn duplicate_arguments(span: &Span, module: &str, function: &str) -> LisetteDiagnostic {
607 let display_module = module.strip_prefix("go:").unwrap_or(module);
608 LisetteDiagnostic::warn("Duplicate arguments")
609 .with_lint_code("duplicate_arguments")
610 .with_span_label(span, "identical arguments")
611 .with_help(format!(
612 "Passing the same value twice to `{display_module}.{function}` makes this call a no-op. Did you mean to pass different values?"
613 ))
614}
615
616pub fn lost_query_mutation(span: &Span, method: &str) -> LisetteDiagnostic {
617 LisetteDiagnostic::warn("Lost query mutation")
618 .with_lint_code("lost_query_mutation")
619 .with_span_label(span, "mutates a discarded copy")
620 .with_help(format!(
621 "`URL.Query` returns a fresh copy, so this `{method}` has no effect. Bind the copy returned by `Query()` to an identifier, mutate it, then assign `values.Encode()` back to the URL's `RawQuery` field."
622 ))
623}
624
625pub fn waitgroup_add_in_task(span: &Span) -> LisetteDiagnostic {
626 LisetteDiagnostic::warn("`WaitGroup.Add` inside a `task`")
627 .with_lint_code("waitgroup_add_in_task")
628 .with_span_label(span, "may run after `Wait`")
629 .with_help(
630 "Prefer `wg.Go(|| ...)`, which counts the task and starts it in one step and runs `Done` for you, or move `Add` before the `task`",
631 )
632}
633
634pub fn unnecessary_range_loop(span: &Span, collection: &str) -> LisetteDiagnostic {
635 LisetteDiagnostic::info("Unnecessary range loop")
636 .with_lint_code("unnecessary_range_loop")
637 .with_span_label(span, "can be simpler")
638 .with_help(format!(
639 "This loop exposes the index only to access elements of `{collection}`. Iterate directly over the elements with `for value in {collection}`"
640 ))
641}