Fix clippy reports

alecalvop · alecalvop · commit 59ad6296d3a1 · 2025-09-05T14:15:17.000-06:00
diff --git a/src/analysis/parsing/expression.rs b/src/analysis/parsing/expression.rs
@@ -42,7 +42,7 @@ impl TreeElement for UnaryExpressionContent {
         create_subs!(&self.operation, &self.expr)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));
+        rules.nsp_unary.check(NspUnaryArgs::from_unary_expr(self), acc);
     }
 }
 
@@ -76,7 +76,7 @@ impl TreeElement for PostUnaryExpressionContent {
         create_subs!(&self.expr, &self.operation)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));
+        rules.nsp_unary.check(NspUnaryArgs::from_postunary_expr(self), acc);
     }
 }
 
@@ -95,7 +95,7 @@ impl TreeElement for BinaryExpressionContent {
         create_subs!(&self.left, &self.operation, &self.right)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_binop.check(acc, SpBinopArgs::from_binary_expression_content(self));
+        rules.sp_binop.check(SpBinopArgs::from_binary_expression_content(self), acc);
     }
 }
 
@@ -157,7 +157,7 @@ impl TreeElement for TertiaryExpressionContent {
                      &self.middle, &self.right_operation, &self.right)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_ternary.check(acc, SpTernaryArgs::from_tertiary_expression_content(self));
+        rules.sp_ternary.check(SpTernaryArgs::from_tertiary_expression_content(self), acc);
     }
 }
 
@@ -176,7 +176,7 @@ impl TreeElement for ParenExpressionContent {
         create_subs!(&self.lparen, &self.expr, &self.rparen)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_paren_expression(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_paren_expression(self), acc);
     }
 }
 
@@ -223,10 +223,10 @@ impl TreeElement for FunctionCallContent {
         }
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_funpar.check(acc, NspFunparArgs::from_function_call(self));
-        rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));
-        rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_function_call(self));
+        rules.nsp_funpar.check(NspFunparArgs::from_function_call(self), acc);
+        rules.nsp_inparen.check(NspInparenArgs::from_function_call(self), acc);
+        rules.sp_punct.check(SpPunctArgs::from_function_call(self), acc);
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_function_call(self), acc);
     }
 }
 
@@ -341,7 +341,7 @@ impl TreeElement for CastContent {
                      &self.comma, &self.to, &self.rparen)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_cast(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_cast(self), acc);
     }
 }
 
@@ -438,7 +438,7 @@ impl TreeElement for IndexContent {
         create_subs!(&self.array, &self.lbracket, &self.index, &self.rbracket)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_inparen.check(acc, NspInparenArgs::from_index(self));
+        rules.nsp_inparen.check(NspInparenArgs::from_index(self), acc);
     }
 }
 
diff --git a/src/analysis/parsing/misc.rs b/src/analysis/parsing/misc.rs
@@ -594,8 +594,8 @@ impl TreeElement for CDeclContent {
                      &self.modifiers, &self.decl)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_ptrdecl.check(acc, SpPtrDeclArgs::from_cdecl(self));
-        rules.nsp_ptrdecl.check(acc, NspPtrDeclArgs::from_cdecl(self));
+        rules.sp_ptrdecl.check(SpPtrDeclArgs::from_cdecl(self), acc);
+        rules.nsp_ptrdecl.check(NspPtrDeclArgs::from_cdecl(self), acc);
     }
 }
 
diff --git a/src/analysis/parsing/statement.rs b/src/analysis/parsing/statement.rs
@@ -146,9 +146,9 @@ impl TreeElement for CompoundContent {
         create_subs!(&self.lbrace, &self.statements, &self.rbrace)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));
-        rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_compound_content(self, aux.depth));
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_compound_content(self, aux.depth));
+        rules.sp_brace.check(SpBracesArgs::from_compound(self), acc);
+        rules.indent_code_block.check(IndentCodeBlockArgs::from_compound_content(self, aux.depth), acc);
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_compound_content(self, aux.depth), acc);
     }
     fn should_increment_depth(&self) -> bool {
         true
@@ -204,7 +204,7 @@ impl TreeElement for VariableDeclContent {
         self.decls.ensure_named()
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));
+        rules.sp_punct.check(SpPunctArgs::from_variable_decl(self), acc);
     }
 }
 
@@ -436,9 +436,9 @@ impl TreeElement for IfContent {
                      &self.elsebranch)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_if(self));
-        rules.sp_reserved.check(acc, SpReservedArgs::from_if(self));
+        rules.nsp_inparen.check(NspInparenArgs::from_if(self), acc);
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_if(self), acc);
+        rules.sp_reserved.check(SpReservedArgs::from_if(self), acc);
     }
 }
 
@@ -550,9 +550,9 @@ impl TreeElement for WhileContent {
                      &self.statement)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_while(self));
-        rules.indent_empty_loop.check(acc, IndentEmptyLoopArgs::from_while_content(self, aux.depth));
-        rules.sp_reserved.check(acc, SpReservedArgs::from_while(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_while(self), acc);
+        rules.indent_empty_loop.check(IndentEmptyLoopArgs::from_while_content(self, aux.depth), acc);
+        rules.sp_reserved.check(SpReservedArgs::from_while(self), acc);
     }
 }
 
@@ -602,7 +602,7 @@ impl TreeElement for DoContent {
                      &self.semi)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_do_while(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_do_while(self), acc);
     }
 }
 
@@ -867,9 +867,9 @@ impl TreeElement for ForContent {
                      &self.statement)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_for(self));
-        rules.indent_empty_loop.check(acc, IndentEmptyLoopArgs::from_for_content(self, aux.depth));
-        rules.sp_reserved.check(acc, SpReservedArgs::from_for(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_for(self), acc);
+        rules.indent_empty_loop.check(IndentEmptyLoopArgs::from_for_content(self, aux.depth), acc);
+        rules.sp_reserved.check(SpReservedArgs::from_for(self), acc);
     }
 }
 
@@ -1028,7 +1028,7 @@ impl TreeElement for SwitchCase {
         }
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.indent_switch_case.check(acc, IndentSwitchCaseArgs::from_switch_case(self, aux.depth));
+        rules.indent_switch_case.check(IndentSwitchCaseArgs::from_switch_case(self, aux.depth), acc);
     }
     fn should_increment_depth(&self) -> bool {
         matches!(self, SwitchCase::Statement(statement)
@@ -1118,8 +1118,8 @@ impl TreeElement for SwitchContent {
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>,
                       rules: &CurrentRules, aux: AuxParams)
     {
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_switch_content(self, aux.depth));
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_switch(self));
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_switch_content(self, aux.depth), acc);
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_switch(self), acc);
     }
 }
 
@@ -1290,7 +1290,7 @@ impl TreeElement for AfterContent {
                      &self.semi)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_reserved.check(acc, SpReservedArgs::from_after_content(self));
+        rules.sp_reserved.check(SpReservedArgs::from_after_content(self), acc);
     }
 }
 
@@ -1618,7 +1618,7 @@ impl TreeElement for ForeachContent {
                      &self.statement)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_foreach(self));
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_foreach(self), acc);
     }
 }
 
@@ -1757,7 +1757,7 @@ impl TreeElement for ExpressionStmtContent {
         create_subs!(&self.expression, &self.semi)
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.sp_punct.check(acc, SpPunctArgs::from_expression_stmt(self));
+        rules.sp_punct.check(SpPunctArgs::from_expression_stmt(self), acc);
     }
 }
 
diff --git a/src/analysis/parsing/structure.rs b/src/analysis/parsing/structure.rs
@@ -233,10 +233,10 @@ impl TreeElement for MethodContent {
         errors
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
-        rules.nsp_funpar.check(acc, NspFunparArgs::from_method(self));
-        rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));
-        rules.sp_punct.check(acc, SpPunctArgs::from_method(self));
-        rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_method(self));
+        rules.nsp_funpar.check(NspFunparArgs::from_method(self), acc);
+        rules.nsp_inparen.check(NspInparenArgs::from_method(self), acc);
+        rules.sp_punct.check(SpPunctArgs::from_method(self), acc);
+        rules.indent_paren_expr.check(IndentParenExprArgs::from_method(self), acc);
     }
 }
 
@@ -703,9 +703,9 @@ impl TreeElement for ObjectStatementsContent {
         }
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.sp_brace.check(acc, SpBracesArgs::from_obj_stmts(self));
-        rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_obj_stmts_content(self, aux.depth));
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_obj_stmts_content(self, aux.depth));
+        rules.sp_brace.check(SpBracesArgs::from_obj_stmts(self), acc);
+        rules.indent_code_block.check(IndentCodeBlockArgs::from_obj_stmts_content(self, aux.depth), acc);
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_obj_stmts_content(self, aux.depth), acc);
     }
     fn should_increment_depth(&self) -> bool {
         matches!(self, ObjectStatementsContent::List(lbrace, list, rbrace)
diff --git a/src/analysis/parsing/types.rs b/src/analysis/parsing/types.rs
@@ -55,9 +55,9 @@ impl TreeElement for StructTypeContent {
         errors
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_struct_type_content(self, aux.depth));
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_struct_type_content(self, aux.depth));
-        rules.sp_brace.check(acc, SpBracesArgs::from_struct_type_content(self));
+        rules.indent_code_block.check(IndentCodeBlockArgs::from_struct_type_content(self, aux.depth), acc);
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_struct_type_content(self, aux.depth), acc);
+        rules.sp_brace.check(SpBracesArgs::from_struct_type_content(self), acc);
     }
     fn should_increment_depth(&self) -> bool {
         true
@@ -138,9 +138,9 @@ impl TreeElement for LayoutContent {
         errors
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_layout_content(self, aux.depth));
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_layout_content(self, aux.depth));
-        rules.sp_brace.check(acc, SpBracesArgs::from_layout_content(self));
+        rules.indent_code_block.check(IndentCodeBlockArgs::from_layout_content(self, aux.depth), acc);
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_layout_content(self, aux.depth), acc);
+        rules.sp_brace.check(SpBracesArgs::from_layout_content(self), acc);
     }
     fn should_increment_depth(&self) -> bool {
         true
@@ -315,9 +315,9 @@ impl TreeElement for BitfieldsContent {
         errors
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
-        rules.sp_brace.check(acc, SpBracesArgs::from_bitfields_content(self));
-        rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_bitfields_content(self, aux.depth));
-        rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_bitfields_content(self, aux.depth));
+        rules.sp_brace.check(SpBracesArgs::from_bitfields_content(self), acc);
+        rules.indent_code_block.check(IndentCodeBlockArgs::from_bitfields_content(self, aux.depth), acc);
+        rules.indent_closing_brace.check(IndentClosingBraceArgs::from_bitfields_content(self, aux.depth), acc);
     }
     fn should_increment_depth(&self) -> bool {
         true
diff --git a/src/lint/mod.rs b/src/lint/mod.rs
@@ -185,9 +185,9 @@ pub fn begin_style_check(ast: TopAst, file: String, rules: &CurrentRules) -> Res
     // Per line checks
     let lines: Vec<&str> = file.lines().collect();
     for (row, line) in lines.iter().enumerate() {
-        rules.indent_no_tabs.check(&mut linting_errors, row, line);
-        rules.long_lines.check(&mut linting_errors, row, line);
-        rules.nsp_trailing.check(&mut linting_errors, row, line);
+        rules.indent_no_tabs.check(row, line, &mut linting_errors);
+        rules.long_lines.check(row, line, &mut linting_errors);
+        rules.nsp_trailing.check(row, line, &mut linting_errors);
     }
 
     post_process_linting_errors(&mut linting_errors);
diff --git a/src/lint/rules/indentation.rs b/src/lint/rules/indentation.rs
@@ -59,7 +59,7 @@ impl LongLinesRule {
             },
         }
     }
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {
+    pub fn check(&self, row: usize, line: &str, acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let len = line.len().try_into().unwrap();
         if len > self.max_length {
@@ -95,7 +95,7 @@ pub struct IndentNoTabRule {
 }
 
 impl IndentNoTabRule {
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {
+    pub fn check(&self, row: usize, line: &str, acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let rowu32 = row.try_into().unwrap();
 
@@ -197,9 +197,9 @@ impl IndentCodeBlockRule {
             }
         }
     }
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
-        args: Option<IndentCodeBlockArgs>)
-    {
+    pub fn check(&self,
+                 args: Option<IndentCodeBlockArgs>,
+                 acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if args.members_ranges.is_empty() { return; }
@@ -340,7 +340,9 @@ impl IndentClosingBraceRule {
         }
     }
 
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<IndentClosingBraceArgs>) {
+    pub fn check(&self,
+                 args: Option<IndentClosingBraceArgs>,
+                 acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
 
@@ -489,8 +491,9 @@ impl IndentParenExprArgs {
 }
 
 impl IndentParenExprRule {
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
-        args: Option<IndentParenExprArgs>) {
+    pub fn check(&self,
+                 args: Option<IndentParenExprArgs>,
+                 acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         let expected_line_start = args.lparen.col_start.0 + 1;
@@ -573,9 +576,9 @@ impl IndentSwitchCaseRule {
             }
         }
     }
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
-        args: Option<IndentSwitchCaseArgs>)
-    {
+    pub fn check(&self,
+                 args: Option<IndentSwitchCaseArgs>,
+                 acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if self.indentation_is_not_aligned(args.case_range, args.expected_depth) {
@@ -659,9 +662,9 @@ impl IndentEmptyLoopRule {
             }
         }
     }
-    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
-        args: Option<IndentEmptyLoopArgs>)
-    {
+    pub fn check(&self,
+                 args: Option<IndentEmptyLoopArgs>,
+                 acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if self.indentation_is_not_aligned(args.semicolon_range, args.expected_depth) ||
diff --git a/src/lint/rules/spacing.rs b/src/lint/rules/spacing.rs

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ impl TreeElement for UnaryExpressionContent {`
`42`	`42`	`create_subs!(&self.operation, &self.expr)`
`43`	`43`	`}`
`44`	`44`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`45`		`- rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));`
	`45`	`+ rules.nsp_unary.check(NspUnaryArgs::from_unary_expr(self), acc);`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`@@ -76,7 +76,7 @@ impl TreeElement for PostUnaryExpressionContent {`
`76`	`76`	`create_subs!(&self.expr, &self.operation)`
`77`	`77`	`}`
`78`	`78`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`79`		`- rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));`
	`79`	`+ rules.nsp_unary.check(NspUnaryArgs::from_postunary_expr(self), acc);`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`@@ -95,7 +95,7 @@ impl TreeElement for BinaryExpressionContent {`
`95`	`95`	`create_subs!(&self.left, &self.operation, &self.right)`
`96`	`96`	`}`
`97`	`97`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`98`		`- rules.sp_binop.check(acc, SpBinopArgs::from_binary_expression_content(self));`
	`98`	`+ rules.sp_binop.check(SpBinopArgs::from_binary_expression_content(self), acc);`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`@@ -157,7 +157,7 @@ impl TreeElement for TertiaryExpressionContent {`
`157`	`157`	`&self.middle, &self.right_operation, &self.right)`
`158`	`158`	`}`
`159`	`159`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`160`		`- rules.sp_ternary.check(acc, SpTernaryArgs::from_tertiary_expression_content(self));`
	`160`	`+ rules.sp_ternary.check(SpTernaryArgs::from_tertiary_expression_content(self), acc);`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`@@ -176,7 +176,7 @@ impl TreeElement for ParenExpressionContent {`
`176`	`176`	`create_subs!(&self.lparen, &self.expr, &self.rparen)`
`177`	`177`	`}`
`178`	`178`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`179`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_paren_expression(self));`
	`179`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_paren_expression(self), acc);`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`@@ -223,10 +223,10 @@ impl TreeElement for FunctionCallContent {`
`223`	`223`	`}`
`224`	`224`	`}`
`225`	`225`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`226`		`- rules.nsp_funpar.check(acc, NspFunparArgs::from_function_call(self));`
`227`		`- rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));`
`228`		`- rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));`
`229`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_function_call(self));`
	`226`	`+ rules.nsp_funpar.check(NspFunparArgs::from_function_call(self), acc);`
	`227`	`+ rules.nsp_inparen.check(NspInparenArgs::from_function_call(self), acc);`
	`228`	`+ rules.sp_punct.check(SpPunctArgs::from_function_call(self), acc);`
	`229`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_function_call(self), acc);`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`
`@@ -341,7 +341,7 @@ impl TreeElement for CastContent {`
`341`	`341`	`&self.comma, &self.to, &self.rparen)`
`342`	`342`	`}`
`343`	`343`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`344`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_cast(self));`
	`344`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_cast(self), acc);`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`@@ -438,7 +438,7 @@ impl TreeElement for IndexContent {`
`438`	`438`	`create_subs!(&self.array, &self.lbracket, &self.index, &self.rbracket)`
`439`	`439`	`}`
`440`	`440`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`441`		`- rules.nsp_inparen.check(acc, NspInparenArgs::from_index(self));`
	`441`	`+ rules.nsp_inparen.check(NspInparenArgs::from_index(self), acc);`
`442`	`442`	`}`
`443`	`443`	`}`
`444`	`444`
Original file line number	Diff line number	Diff line change
`@@ -594,8 +594,8 @@ impl TreeElement for CDeclContent {`
`594`	`594`	`&self.modifiers, &self.decl)`
`595`	`595`	`}`
`596`	`596`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`597`		`- rules.sp_ptrdecl.check(acc, SpPtrDeclArgs::from_cdecl(self));`
`598`		`- rules.nsp_ptrdecl.check(acc, NspPtrDeclArgs::from_cdecl(self));`
	`597`	`+ rules.sp_ptrdecl.check(SpPtrDeclArgs::from_cdecl(self), acc);`
	`598`	`+ rules.nsp_ptrdecl.check(NspPtrDeclArgs::from_cdecl(self), acc);`
`599`	`599`	`}`
`600`	`600`	`}`
`601`	`601`
Original file line number	Diff line number	Diff line change
`@@ -146,9 +146,9 @@ impl TreeElement for CompoundContent {`
`146`	`146`	`create_subs!(&self.lbrace, &self.statements, &self.rbrace)`
`147`	`147`	`}`
`148`	`148`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {`
`149`		`- rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));`
`150`		`- rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_compound_content(self, aux.depth));`
`151`		`- rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_compound_content(self, aux.depth));`
	`149`	`+ rules.sp_brace.check(SpBracesArgs::from_compound(self), acc);`
	`150`	`+ rules.indent_code_block.check(IndentCodeBlockArgs::from_compound_content(self, aux.depth), acc);`
	`151`	`+ rules.indent_closing_brace.check(IndentClosingBraceArgs::from_compound_content(self, aux.depth), acc);`
`152`	`152`	`}`
`153`	`153`	`fn should_increment_depth(&self) -> bool {`
`154`	`154`	`true`
`@@ -204,7 +204,7 @@ impl TreeElement for VariableDeclContent {`
`204`	`204`	`self.decls.ensure_named()`
`205`	`205`	`}`
`206`	`206`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`207`		`- rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));`
	`207`	`+ rules.sp_punct.check(SpPunctArgs::from_variable_decl(self), acc);`
`208`	`208`	`}`
`209`	`209`	`}`
`210`	`210`
`@@ -436,9 +436,9 @@ impl TreeElement for IfContent {`
`436`	`436`	`&self.elsebranch)`
`437`	`437`	`}`
`438`	`438`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`439`		`- rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));`
`440`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_if(self));`
`441`		`- rules.sp_reserved.check(acc, SpReservedArgs::from_if(self));`
	`439`	`+ rules.nsp_inparen.check(NspInparenArgs::from_if(self), acc);`
	`440`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_if(self), acc);`
	`441`	`+ rules.sp_reserved.check(SpReservedArgs::from_if(self), acc);`
`442`	`442`	`}`
`443`	`443`	`}`
`444`	`444`
`@@ -550,9 +550,9 @@ impl TreeElement for WhileContent {`
`550`	`550`	`&self.statement)`
`551`	`551`	`}`
`552`	`552`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {`
`553`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_while(self));`
`554`		`- rules.indent_empty_loop.check(acc, IndentEmptyLoopArgs::from_while_content(self, aux.depth));`
`555`		`- rules.sp_reserved.check(acc, SpReservedArgs::from_while(self));`
	`553`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_while(self), acc);`
	`554`	`+ rules.indent_empty_loop.check(IndentEmptyLoopArgs::from_while_content(self, aux.depth), acc);`
	`555`	`+ rules.sp_reserved.check(SpReservedArgs::from_while(self), acc);`
`556`	`556`	`}`
`557`	`557`	`}`
`558`	`558`
`@@ -602,7 +602,7 @@ impl TreeElement for DoContent {`
`602`	`602`	`&self.semi)`
`603`	`603`	`}`
`604`	`604`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`605`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_do_while(self));`
	`605`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_do_while(self), acc);`
`606`	`606`	`}`
`607`	`607`	`}`
`608`	`608`
`@@ -867,9 +867,9 @@ impl TreeElement for ForContent {`
`867`	`867`	`&self.statement)`
`868`	`868`	`}`
`869`	`869`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {`
`870`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_for(self));`
`871`		`- rules.indent_empty_loop.check(acc, IndentEmptyLoopArgs::from_for_content(self, aux.depth));`
`872`		`- rules.sp_reserved.check(acc, SpReservedArgs::from_for(self));`
	`870`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_for(self), acc);`
	`871`	`+ rules.indent_empty_loop.check(IndentEmptyLoopArgs::from_for_content(self, aux.depth), acc);`
	`872`	`+ rules.sp_reserved.check(SpReservedArgs::from_for(self), acc);`
`873`	`873`	`}`
`874`	`874`	`}`
`875`	`875`
`@@ -1028,7 +1028,7 @@ impl TreeElement for SwitchCase {`
`1028`	`1028`	`}`
`1029`	`1029`	`}`
`1030`	`1030`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {`
`1031`		`- rules.indent_switch_case.check(acc, IndentSwitchCaseArgs::from_switch_case(self, aux.depth));`
	`1031`	`+ rules.indent_switch_case.check(IndentSwitchCaseArgs::from_switch_case(self, aux.depth), acc);`
`1032`	`1032`	`}`
`1033`	`1033`	`fn should_increment_depth(&self) -> bool {`
`1034`	`1034`	`matches!(self, SwitchCase::Statement(statement)`
`@@ -1118,8 +1118,8 @@ impl TreeElement for SwitchContent {`
`1118`	`1118`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>,`
`1119`	`1119`	`rules: &CurrentRules, aux: AuxParams)`
`1120`	`1120`	`{`
`1121`		`- rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_switch_content(self, aux.depth));`
`1122`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_switch(self));`
	`1121`	`+ rules.indent_closing_brace.check(IndentClosingBraceArgs::from_switch_content(self, aux.depth), acc);`
	`1122`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_switch(self), acc);`
`1123`	`1123`	`}`
`1124`	`1124`	`}`
`1125`	`1125`
`@@ -1290,7 +1290,7 @@ impl TreeElement for AfterContent {`
`1290`	`1290`	`&self.semi)`
`1291`	`1291`	`}`
`1292`	`1292`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`1293`		`- rules.sp_reserved.check(acc, SpReservedArgs::from_after_content(self));`
	`1293`	`+ rules.sp_reserved.check(SpReservedArgs::from_after_content(self), acc);`
`1294`	`1294`	`}`
`1295`	`1295`	`}`
`1296`	`1296`
`@@ -1618,7 +1618,7 @@ impl TreeElement for ForeachContent {`
`1618`	`1618`	`&self.statement)`
`1619`	`1619`	`}`
`1620`	`1620`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`1621`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_foreach(self));`
	`1621`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_foreach(self), acc);`
`1622`	`1622`	`}`
`1623`	`1623`	`}`
`1624`	`1624`
`@@ -1757,7 +1757,7 @@ impl TreeElement for ExpressionStmtContent {`
`1757`	`1757`	`create_subs!(&self.expression, &self.semi)`
`1758`	`1758`	`}`
`1759`	`1759`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`1760`		`- rules.sp_punct.check(acc, SpPunctArgs::from_expression_stmt(self));`
	`1760`	`+ rules.sp_punct.check(SpPunctArgs::from_expression_stmt(self), acc);`
`1761`	`1761`	`}`
`1762`	`1762`	`}`
`1763`	`1763`
Original file line number	Diff line number	Diff line change
`@@ -233,10 +233,10 @@ impl TreeElement for MethodContent {`
`233`	`233`	`errors`
`234`	`234`	`}`
`235`	`235`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {`
`236`		`- rules.nsp_funpar.check(acc, NspFunparArgs::from_method(self));`
`237`		`- rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));`
`238`		`- rules.sp_punct.check(acc, SpPunctArgs::from_method(self));`
`239`		`- rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_method(self));`
	`236`	`+ rules.nsp_funpar.check(NspFunparArgs::from_method(self), acc);`
	`237`	`+ rules.nsp_inparen.check(NspInparenArgs::from_method(self), acc);`
	`238`	`+ rules.sp_punct.check(SpPunctArgs::from_method(self), acc);`
	`239`	`+ rules.indent_paren_expr.check(IndentParenExprArgs::from_method(self), acc);`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`
`@@ -703,9 +703,9 @@ impl TreeElement for ObjectStatementsContent {`
`703`	`703`	`}`
`704`	`704`	`}`
`705`	`705`	`fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {`
`706`		`- rules.sp_brace.check(acc, SpBracesArgs::from_obj_stmts(self));`
`707`		`- rules.indent_code_block.check(acc, IndentCodeBlockArgs::from_obj_stmts_content(self, aux.depth));`
`708`		`- rules.indent_closing_brace.check(acc, IndentClosingBraceArgs::from_obj_stmts_content(self, aux.depth));`
	`706`	`+ rules.sp_brace.check(SpBracesArgs::from_obj_stmts(self), acc);`
	`707`	`+ rules.indent_code_block.check(IndentCodeBlockArgs::from_obj_stmts_content(self, aux.depth), acc);`
	`708`	`+ rules.indent_closing_brace.check(IndentClosingBraceArgs::from_obj_stmts_content(self, aux.depth), acc);`
`709`	`709`	`}`
`710`	`710`	`fn should_increment_depth(&self) -> bool {`
`711`	`711`	`matches!(self, ObjectStatementsContent::List(lbrace, list, rbrace)`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl LongLinesRule {`
`59`	`59`	`},`
`60`	`60`	`}`
`61`	`61`	`}`
`62`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {`
	`62`	`+ pub fn check(&self, row: usize, line: &str, acc: &mut Vec<DMLStyleError>) {`
`63`	`63`	`if !self.enabled { return; }`
`64`	`64`	`let len = line.len().try_into().unwrap();`
`65`	`65`	`if len > self.max_length {`
`@@ -95,7 +95,7 @@ pub struct IndentNoTabRule {`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl IndentNoTabRule {`
`98`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {`
	`98`	`+ pub fn check(&self, row: usize, line: &str, acc: &mut Vec<DMLStyleError>) {`
`99`	`99`	`if !self.enabled { return; }`
`100`	`100`	`let rowu32 = row.try_into().unwrap();`
`101`	`101`
`@@ -197,9 +197,9 @@ impl IndentCodeBlockRule {`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`	`}`
`200`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>,`
`201`		`- args: Option<IndentCodeBlockArgs>)`
`202`		`- {`
	`200`	`+ pub fn check(&self,`
	`201`	`+ args: Option<IndentCodeBlockArgs>,`
	`202`	`+ acc: &mut Vec<DMLStyleError>) {`
`203`	`203`	`if !self.enabled { return; }`
`204`	`204`	`let Some(args) = args else { return; };`
`205`	`205`	`if args.members_ranges.is_empty() { return; }`
`@@ -340,7 +340,9 @@ impl IndentClosingBraceRule {`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`
`343`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<IndentClosingBraceArgs>) {`
	`343`	`+ pub fn check(&self,`
	`344`	`+ args: Option<IndentClosingBraceArgs>,`
	`345`	`+ acc: &mut Vec<DMLStyleError>) {`
`344`	`346`	`if !self.enabled { return; }`
`345`	`347`	`let Some(args) = args else { return; };`
`346`	`348`
`@@ -489,8 +491,9 @@ impl IndentParenExprArgs {`
`489`	`491`	`}`
`490`	`492`
`491`	`493`	`impl IndentParenExprRule {`
`492`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>,`
`493`		`- args: Option<IndentParenExprArgs>) {`
	`494`	`+ pub fn check(&self,`
	`495`	`+ args: Option<IndentParenExprArgs>,`
	`496`	`+ acc: &mut Vec<DMLStyleError>) {`
`494`	`497`	`if !self.enabled { return; }`
`495`	`498`	`let Some(args) = args else { return; };`
`496`	`499`	`let expected_line_start = args.lparen.col_start.0 + 1;`
`@@ -573,9 +576,9 @@ impl IndentSwitchCaseRule {`
`573`	`576`	`}`
`574`	`577`	`}`
`575`	`578`	`}`
`576`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>,`
`577`		`- args: Option<IndentSwitchCaseArgs>)`
`578`		`- {`
	`579`	`+ pub fn check(&self,`
	`580`	`+ args: Option<IndentSwitchCaseArgs>,`
	`581`	`+ acc: &mut Vec<DMLStyleError>) {`
`579`	`582`	`if !self.enabled { return; }`
`580`	`583`	`let Some(args) = args else { return; };`
`581`	`584`	`if self.indentation_is_not_aligned(args.case_range, args.expected_depth) {`
`@@ -659,9 +662,9 @@ impl IndentEmptyLoopRule {`
`659`	`662`	`}`
`660`	`663`	`}`
`661`	`664`	`}`
`662`		`- pub fn check(&self, acc: &mut Vec<DMLStyleError>,`
`663`		`- args: Option<IndentEmptyLoopArgs>)`
`664`		`- {`
	`665`	`+ pub fn check(&self,`
	`666`	`+ args: Option<IndentEmptyLoopArgs>,`
	`667`	`+ acc: &mut Vec<DMLStyleError>) {`
`665`	`668`	`if !self.enabled { return; }`
`666`	`669`	`let Some(args) = args else { return; };`
`667`	`670`	`if self.indentation_is_not_aligned(args.semicolon_range, args.expected_depth) \|\|`