]> git.lizzy.rs Git - rust.git/blob - src/tools/clippy/src/docs/only_used_in_recursion.txt
Merge remote-tracking branch 'origin/master' into mpk/add-long-error-message-for...
[rust.git] / src / tools / clippy / src / docs / only_used_in_recursion.txt
1 ### What it does
2 Checks for arguments that are only used in recursion with no side-effects.
3
4 ### Why is this bad?
5 It could contain a useless calculation and can make function simpler.
6
7 The arguments can be involved in calculations and assignments but as long as
8 the calculations have no side-effects (function calls or mutating dereference)
9 and the assigned variables are also only in recursion, it is useless.
10
11 ### Known problems
12 Too many code paths in the linting code are currently untested and prone to produce false
13 positives or are prone to have performance implications.
14
15 In some cases, this would not catch all useless arguments.
16
17 ```
18 fn foo(a: usize, b: usize) -> usize {
19     let f = |x| x + 1;
20
21     if a == 0 {
22         1
23     } else {
24         foo(a - 1, f(b))
25     }
26 }
27 ```
28
29 For example, the argument `b` is only used in recursion, but the lint would not catch it.
30
31 List of some examples that can not be caught:
32 - binary operation of non-primitive types
33 - closure usage
34 - some `break` relative operations
35 - struct pattern binding
36
37 Also, when you recurse the function name with path segments, it is not possible to detect.
38
39 ### Example
40 ```
41 fn f(a: usize, b: usize) -> usize {
42     if a == 0 {
43         1
44     } else {
45         f(a - 1, b + 1)
46     }
47 }
48 ```
49 Use instead:
50 ```
51 fn f(a: usize) -> usize {
52     if a == 0 {
53         1
54     } else {
55         f(a - 1)
56     }
57 }
58 ```