Lints and suggestions for the Nix programming language
refactor(useless_parens): modernize
+62
-80
+62
-80
lib/src/lints/useless_parens.rs
+62
-80
lib/src/lints/useless_parens.rs
···
45
45
46
46
impl Rule for UselessParens {
47
47
fn validate(&self, node: &SyntaxElement, _sess: &SessionInfo) -> Option<Report> {
48
-
if let NodeOrToken::Node(node) = node
49
-
&& let Some(parsed_type_node) = ParsedType::cast(node.clone())
50
-
&& let Some(diagnostic) = do_thing(parsed_type_node)
51
-
{
52
-
let mut report = self.report();
53
-
report.diagnostics.push(diagnostic);
54
-
Some(report)
55
-
} else {
56
-
None
57
-
}
58
-
}
59
-
}
48
+
let NodeOrToken::Node(node) = node else {
49
+
return None;
50
+
};
60
51
61
-
fn do_thing(parsed_type_node: ParsedType) -> Option<Diagnostic> {
62
-
match parsed_type_node {
63
-
ParsedType::KeyValue(kv) => {
64
-
if let Some(value_node) = kv.value()
65
-
&& let value_range = value_node.text_range()
66
-
&& let Some(value_in_parens) = Paren::cast(value_node)
67
-
&& let Some(inner) = value_in_parens.inner()
68
-
{
69
-
let at = value_range;
70
-
let message = "Useless parentheses around value in binding";
71
-
let replacement = inner;
72
-
Some(Diagnostic::suggest(
73
-
at,
74
-
message,
75
-
Suggestion::new(at, replacement),
76
-
))
77
-
} else {
78
-
None
52
+
let parsed_type_node = ParsedType::cast(node.clone())?;
53
+
54
+
let diagnostic = match parsed_type_node {
55
+
ParsedType::KeyValue(kv) => {
56
+
let value_node = kv.value()?;
57
+
let value_range = value_node.text_range();
58
+
59
+
Diagnostic::suggest(
60
+
value_range,
61
+
"Useless parentheses around value in binding",
62
+
Suggestion::new(value_range, Paren::cast(value_node)?.inner()?),
63
+
)
79
64
}
80
-
}
81
-
ParsedType::LetIn(let_in) => {
82
-
if let Some(body_node) = let_in.body()
83
-
&& let body_range = body_node.text_range()
84
-
&& let Some(body_as_parens) = Paren::cast(body_node)
85
-
&& let Some(inner) = body_as_parens.inner()
86
-
{
87
-
let at = body_range;
88
-
let message = "Useless parentheses around body of `let` expression";
89
-
let replacement = inner;
90
-
Some(Diagnostic::suggest(
91
-
at,
92
-
message,
93
-
Suggestion::new(at, replacement),
94
-
))
95
-
} else {
96
-
None
65
+
ParsedType::LetIn(let_in) => {
66
+
let body_node = let_in.body()?;
67
+
let body_range = body_node.text_range();
68
+
Diagnostic::suggest(
69
+
body_range,
70
+
"Useless parentheses around body of `let` expression",
71
+
Suggestion::new(body_range, Paren::cast(body_node)?.inner()?),
72
+
)
97
73
}
98
-
}
99
-
ParsedType::Paren(paren_expr) => {
100
-
let paren_expr_range = paren_expr.node().text_range();
101
-
if let Some(father_node) = paren_expr.node().parent()
102
-
// ensure that we don't lint inside let-in statements
103
-
// we already lint such cases in previous match stmt
104
-
&& KeyValue::cast(father_node.clone()).is_none()
74
+
ParsedType::Paren(paren_expr) => {
75
+
let paren_expr_range = paren_expr.node().text_range();
76
+
let father_node = paren_expr.node().parent()?;
105
77
106
-
// ensure that we don't lint inside let-bodies
107
-
// if this primitive is a let-body, we have already linted it
108
-
&& LetIn::cast(father_node).is_none()
78
+
// ensure that we don't lint inside let-in statements
79
+
// we already lint such cases in previous match stmt
80
+
if KeyValue::cast(father_node.clone()).is_some() {
81
+
return None;
82
+
}
83
+
84
+
// ensure that we don't lint inside let-bodies
85
+
// if this primitive is a let-body, we have already linted it
86
+
if LetIn::cast(father_node).is_some() {
87
+
return None;
88
+
}
89
+
90
+
let parsed_inner = ParsedType::cast(paren_expr.inner()?)?;
91
+
92
+
if !matches!(
93
+
parsed_inner,
94
+
ParsedType::List(_)
95
+
| ParsedType::Paren(_)
96
+
| ParsedType::Str(_)
97
+
| ParsedType::AttrSet(_)
98
+
| ParsedType::Select(_)
99
+
| ParsedType::Ident(_)
100
+
) {
101
+
return None;
102
+
}
109
103
110
-
&& let Some(inner_node) = paren_expr.inner()
111
-
&& let Some(parsed_inner) = ParsedType::cast(inner_node)
112
-
&& matches!(
113
-
parsed_inner,
114
-
ParsedType::List(_)
115
-
| ParsedType::Paren(_)
116
-
| ParsedType::Str(_)
117
-
| ParsedType::AttrSet(_)
118
-
| ParsedType::Select(_)
119
-
| ParsedType::Ident(_)
120
-
) {
121
-
let at = paren_expr_range;
122
-
let message = "Useless parentheses around primitive expression";
123
-
let replacement = parsed_inner.node().clone();
124
-
Some(Diagnostic::suggest(
125
-
at,
126
-
message,
127
-
Suggestion::new(at, replacement),
128
-
))
129
-
} else {
130
-
None
104
+
Diagnostic::suggest(
105
+
paren_expr_range,
106
+
"Useless parentheses around primitive expression",
107
+
Suggestion::new(paren_expr_range, parsed_inner.node().clone()),
108
+
)
131
109
}
132
-
}
133
-
_ => None,
110
+
_ => return None,
111
+
};
112
+
113
+
let mut report = self.report();
114
+
report.diagnostics.push(diagnostic);
115
+
Some(report)
134
116
}
135
117
}