Lints and suggestions for the Nix programming language
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

refactor: empty replacement without parsing empty string

+48 -29
+26 -4
lib/src/lib.rs
··· 179 179 } 180 180 } 181 181 182 + #[derive(Debug)] 183 + pub enum Replacement { 184 + Empty, 185 + SyntaxElement(SyntaxElement), 186 + } 187 + 182 188 /// Suggested fix for a diagnostic, the fix is provided as a syntax element. 183 189 /// Look at `make.rs` to construct fixes. 184 190 #[derive(Debug)] 185 191 pub struct Suggestion { 186 192 pub at: TextRange, 187 - pub fix: SyntaxElement, 193 + pub fix: Replacement, 194 + } 195 + 196 + impl std::fmt::Display for Replacement { 197 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 198 + match self { 199 + Replacement::Empty => Ok(()), 200 + Replacement::SyntaxElement(syntax_element) => write!(f, "{syntax_element}"), 201 + } 202 + } 188 203 } 189 204 190 205 impl Suggestion { 191 - /// Construct a suggestion. 192 - pub fn new(at: TextRange, fix: impl Into<SyntaxElement>) -> Self { 206 + #[must_use] 207 + pub fn with_replacement(at: TextRange, fix: impl Into<SyntaxElement>) -> Self { 208 + Self { 209 + at, 210 + fix: Replacement::SyntaxElement(fix.into()), 211 + } 212 + } 213 + #[must_use] 214 + pub fn with_empty(at: TextRange) -> Self { 193 215 Self { 194 216 at, 195 - fix: fix.into(), 217 + fix: Replacement::Empty, 196 218 } 197 219 } 198 220 /// Apply a suggestion to a source file
+1 -1
lib/src/lints/bool_comparison.rs
··· 86 86 Some(self.report().suggest( 87 87 at, 88 88 format!("Comparing `{non_bool_side}` with boolean literal `{bool_side}`"), 89 - Suggestion::new(at, replacement), 89 + Suggestion::with_replacement(at, replacement), 90 90 )) 91 91 } 92 92 }
+1 -1
lib/src/lints/bool_simplification.rs
··· 59 59 let replacement = make::binary(&lhs, "!=", &rhs).node().clone(); 60 60 Some( 61 61 self.report() 62 - .suggest(at, message, Suggestion::new(at, replacement)), 62 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 63 63 ) 64 64 } 65 65 }
+2 -3
lib/src/lints/collapsible_let_in.rs
··· 1 - use crate::{Metadata, Report, Rule, Suggestion, make, session::SessionInfo}; 1 + use crate::{Metadata, Report, Rule, Suggestion, session::SessionInfo}; 2 2 3 3 use macros::lint; 4 4 use rnix::{ ··· 73 73 .end(); 74 74 TextRange::new(start, end) 75 75 }; 76 - let replacement = make::empty().node().clone(); 77 76 78 77 Some( 79 78 self.report() ··· 81 80 .suggest( 82 81 second_annotation, 83 82 second_message, 84 - Suggestion::new(replacement_at, replacement), 83 + Suggestion::with_empty(replacement_at), 85 84 ), 86 85 ) 87 86 }
+2 -3
lib/src/lints/empty_inherit.rs
··· 1 - use crate::{Metadata, Report, Rule, Suggestion, make, session::SessionInfo, utils}; 1 + use crate::{Metadata, Report, Rule, Suggestion, session::SessionInfo, utils}; 2 2 3 3 use macros::lint; 4 4 use rnix::{ ··· 44 44 } 45 45 46 46 let at = node.text_range(); 47 - let replacement = make::empty().node().clone(); 48 47 let replacement_at = utils::with_preceeding_whitespace(node); 49 48 let message = "Remove this empty `inherit` statement"; 50 49 Some( 51 50 self.report() 52 - .suggest(at, message, Suggestion::new(replacement_at, replacement)), 51 + .suggest(at, message, Suggestion::with_empty(replacement_at)), 53 52 ) 54 53 } 55 54 }
+1 -1
lib/src/lints/empty_let_in.rs
··· 54 54 self.report().diagnostic(at, message) 55 55 } else { 56 56 self.report() 57 - .suggest(at, message, Suggestion::new(at, replacement)) 57 + .suggest(at, message, Suggestion::with_replacement(at, replacement)) 58 58 }) 59 59 } else { 60 60 None
+1 -1
lib/src/lints/empty_list_concat.rs
··· 56 56 57 57 Some( 58 58 self.report() 59 - .suggest(at, message, Suggestion::new(at, empty_array)), 59 + .suggest(at, message, Suggestion::with_replacement(at, empty_array)), 60 60 ) 61 61 } 62 62 }
+4 -1
lib/src/lints/empty_pattern.rs
··· 65 65 Some(self.report().suggest( 66 66 pattern.node().text_range(), 67 67 "This pattern is empty, use `_` instead", 68 - Suggestion::new(pattern.node().text_range(), make::ident("_").node().clone()), 68 + Suggestion::with_replacement( 69 + pattern.node().text_range(), 70 + make::ident("_").node().clone(), 71 + ), 69 72 )) 70 73 } 71 74 }
+1 -1
lib/src/lints/eta_reduction.rs
··· 69 69 let message = format!("Found eta-reduction: `{}`", replacement.text()); 70 70 Some( 71 71 self.report() 72 - .suggest(at, message, Suggestion::new(at, replacement)), 72 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 73 73 ) 74 74 } 75 75 }
+1 -1
lib/src/lints/legacy_let_syntax.rs
··· 62 62 63 63 Some( 64 64 self.report() 65 - .suggest(at, message, Suggestion::new(at, replacement)), 65 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 66 66 ) 67 67 } else { 68 68 None
+1 -1
lib/src/lints/manual_inherit.rs
··· 65 65 Some(self.report().suggest( 66 66 node.text_range(), 67 67 "This assignment is better written with `inherit`", 68 - Suggestion::new(node.text_range(), replacement), 68 + Suggestion::with_replacement(node.text_range(), replacement), 69 69 )) 70 70 } 71 71 }
+1 -1
lib/src/lints/manual_inherit_from.rs
··· 70 70 Some(self.report().suggest( 71 71 at, 72 72 "This assignment is better written with `inherit`", 73 - Suggestion::new(at, replacement), 73 + Suggestion::with_replacement(at, replacement), 74 74 )) 75 75 } 76 76 }
+1 -1
lib/src/lints/redundant_pattern_bind.rs
··· 62 62 63 63 Some( 64 64 self.report() 65 - .suggest(at, message, Suggestion::new(at, replacement)), 65 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 66 66 ) 67 67 } 68 68 }
+1 -1
lib/src/lints/unquoted_uri.rs
··· 56 56 let message = "Consider quoting this URI expression"; 57 57 Some( 58 58 self.report() 59 - .suggest(at, message, Suggestion::new(at, replacement)), 59 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 60 60 ) 61 61 } 62 62 }
+1 -1
lib/src/lints/useless_has_attr.rs
··· 80 80 let message = format!("Consider using `{replacement}` instead of this `if` expression"); 81 81 Some( 82 82 self.report() 83 - .suggest(at, message, Suggestion::new(at, replacement)), 83 + .suggest(at, message, Suggestion::with_replacement(at, replacement)), 84 84 ) 85 85 } 86 86 }
+3 -3
lib/src/lints/useless_parens.rs
··· 59 59 Diagnostic::suggest( 60 60 value_range, 61 61 "Useless parentheses around value in binding", 62 - Suggestion::new(value_range, Paren::cast(value_node)?.inner()?), 62 + Suggestion::with_replacement(value_range, Paren::cast(value_node)?.inner()?), 63 63 ) 64 64 } 65 65 ParsedType::LetIn(let_in) => { ··· 68 68 Diagnostic::suggest( 69 69 body_range, 70 70 "Useless parentheses around body of `let` expression", 71 - Suggestion::new(body_range, Paren::cast(body_node)?.inner()?), 71 + Suggestion::with_replacement(body_range, Paren::cast(body_node)?.inner()?), 72 72 ) 73 73 } 74 74 ParsedType::Paren(paren_expr) => { ··· 104 104 Diagnostic::suggest( 105 105 paren_expr_range, 106 106 "Useless parentheses around primitive expression", 107 - Suggestion::new(paren_expr_range, parsed_inner.node().clone()), 107 + Suggestion::with_replacement(paren_expr_range, parsed_inner.node().clone()), 108 108 ) 109 109 } 110 110 _ => return None,
-4
lib/src/make.rs
··· 80 80 ast_from_text(text) 81 81 } 82 82 83 - pub fn empty() -> types::Root { 84 - ast_from_text("") 85 - } 86 - 87 83 // LATER: make `op` strongly typed here 88 84 pub fn binary(lhs: &SyntaxNode, op: &str, rhs: &SyntaxNode) -> types::BinOp { 89 85 ast_from_text(&format!("{lhs} {op} {rhs}"))