Move depth to AuxParams struct for node info

jvsqzj · jvsqzj · commit 2c0367e35147 · 2025-02-06T12:14:35.000-08:00
diff --git a/src/analysis/parsing/expression.rs b/src/analysis/parsing/expression.rs
@@ -17,11 +17,12 @@ use crate::analysis::structure::expressions::DMLString;
 use crate::analysis::{DeclarationSpan, LocalDMLError};
 
 
-use crate::lint::rules::spacing::{NspFunparArgs,
-                                  NspInparenArgs,
-                                  NspUnaryArgs,
-                                  SpPunctArgs};
-use crate::lint::rules::CurrentRules;
+use crate::lint::{rules::{spacing::{NspFunparArgs,
+                                    NspInparenArgs,
+                                    NspUnaryArgs,
+                                    SpPunctArgs},
+                                    CurrentRules},
+                                    AuxParams};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct UnaryExpressionContent {
@@ -36,7 +37,7 @@ impl TreeElement for UnaryExpressionContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.operation, &self.expr)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));
     }
 }
@@ -70,7 +71,7 @@ impl TreeElement for PostUnaryExpressionContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.expr, &self.operation)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));
     }
 }
@@ -208,7 +209,7 @@ impl TreeElement for FunctionCallContent {
                 noderef, ReferenceKind::Callable));
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut 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));
@@ -419,7 +420,7 @@ impl TreeElement for IndexContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.array, &self.lbracket, &self.index, &self.rbracket)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_inparen.check(acc, NspInparenArgs::from_index(self));
     }
 }
diff --git a/src/analysis/parsing/statement.rs b/src/analysis/parsing/statement.rs
@@ -21,12 +21,12 @@ use crate::analysis::parsing::misc::{Initializer, InitializerContent, CDecl,
                                      ident_filter, objident_filter};
 use crate::analysis::parsing::structure::{parse_vardecl, VarDecl};
 use crate::analysis::LocalDMLError;
-use crate::lint::rules::{CurrentRules,
+use crate::lint::{rules::{CurrentRules,
                          indentation::{IN3Args, IN9Args},
                          spacing::{NspInparenArgs,
                                    SpBracesArgs,
-                                   SpPunctArgs},
-                        };
+                                   SpPunctArgs}},
+                                   AuxParams};
 use crate::vfs::TextFile;
 
 fn statement_contexts(context: &ParseContext)
@@ -141,9 +141,9 @@ impl TreeElement for CompoundContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.lbrace, &self.statements, &self.rbrace)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
         rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));
-        rules.in3.check(acc, IN3Args::from_compound_content(self, depth));
+        rules.in3.check(acc, IN3Args::from_compound_content(self, &mut aux.depth));
     }
 }
 
@@ -195,7 +195,7 @@ impl TreeElement for VariableDeclContent {
     fn post_parse_sanity(&self, _file: &TextFile) -> Vec<LocalDMLError> {
         self.decls.ensure_named()
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));
     }
 }
@@ -427,7 +427,7 @@ impl TreeElement for IfContent {
                      &self.truebranch,
                      &self.elsebranch)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));
     }
 }
@@ -1003,8 +1003,8 @@ impl TreeElement for SwitchCase {
             Self::Default(default, colon) => create_subs!(default, colon),
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {
-        rules.in9.check(acc, IN9Args::from_switch_case(self, depth));
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+        rules.in9.check(acc, IN9Args::from_switch_case(self, &mut aux.depth));
     }
 }
 
@@ -1715,7 +1715,7 @@ impl TreeElement for ExpressionStmtContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.expression, &self.semi)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.sp_punct.check(acc, SpPunctArgs::from_expression_stmt(self));
     }
 }
diff --git a/src/analysis/parsing/structure.rs b/src/analysis/parsing/structure.rs
@@ -21,7 +21,7 @@ use crate::lint::rules::spacing::{SpBracesArgs,
                                   NspFunparArgs,
                                   SpPunctArgs};
 use crate::lint::rules::indentation::{IN3Args};
-use crate::lint::rules::CurrentRules;
+use crate::lint::{rules::CurrentRules, AuxParams};
 use crate::analysis::reference::{Reference, ReferenceKind};
 use crate::analysis::FileSpec;
 use crate::span::Range;
@@ -235,7 +235,7 @@ impl TreeElement for MethodContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut 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));
@@ -704,9 +704,9 @@ impl TreeElement for ObjectStatementsContent {
                 create_subs!(left, vect, right)
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
         rules.sp_brace.check(acc, SpBracesArgs::from_obj_stmts(self));
-        rules.in3.check(acc, IN3Args::from_obj_stmts_content(self, depth));
+        rules.in3.check(acc, IN3Args::from_obj_stmts_content(self, &mut aux.depth));
     }
 }
 
diff --git a/src/analysis/parsing/tree.rs b/src/analysis/parsing/tree.rs
@@ -7,7 +7,7 @@ use crate::analysis::reference::{Reference, NodeRef, MaybeIsNodeRef,
 use crate::analysis::FileSpec;
 use crate::analysis::structure::expressions::DMLString;
 
-use crate::lint::rules::CurrentRules;
+use crate::lint::{rules::CurrentRules, AuxParams};
 use crate::span::{Range, Span, ZeroIndexed, Position, FilePosition};
 use crate::vfs::{Vfs as GenVfs, TextFile};
 
@@ -91,13 +91,13 @@ pub trait TreeElement {
         self.default_references(accumulator, file);
     }
 
-    fn style_check(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, mut depth: u32) {
-        self.evaluate_rules(acc, rules, &mut depth);
+    fn style_check(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, mut aux: AuxParams) {
+        self.evaluate_rules(acc, rules, &mut aux);
         for sub in self.subs() {
-            sub.style_check(acc, rules, depth);
+            sub.style_check(acc, rules, aux);
         }
     }
-    fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _depth: &mut u32) {} // default NOOP
+    fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _aux: &mut AuxParams) {} // default NOOP
 }
 
 impl <T: ?Sized + TreeElement> ReferenceContainer for T {
diff --git a/src/analysis/parsing/types.rs b/src/analysis/parsing/types.rs
@@ -1,8 +1,9 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
-use crate::lint::rules::{indentation::IN3Args,
-                         spacing::SpBracesArgs,
-                         CurrentRules};
+use crate::lint::{rules::{indentation::IN3Args,
+                            spacing::SpBracesArgs,
+                            CurrentRules},
+                            AuxParams};
 use crate::span::Range;
 use crate::analysis::parsing::lexer::TokenKind;
 use crate::analysis::parsing::parser::{doesnt_understand_tokens,
@@ -51,8 +52,8 @@ impl TreeElement for StructTypeContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {
-        rules.in3.check(acc, IN3Args::from_struct_type_content(self, depth));
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+        rules.in3.check(acc, IN3Args::from_struct_type_content(self, &mut aux.depth));
         rules.sp_brace.check(acc, SpBracesArgs::from_struct_type_content(self));
     }
 }
@@ -130,8 +131,8 @@ impl TreeElement for LayoutContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {
-        rules.in3.check(acc, IN3Args::from_layout_content(self, depth));
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+        rules.in3.check(acc, IN3Args::from_layout_content(self, &mut aux.depth));
         rules.sp_brace.check(acc, SpBracesArgs::from_layout_content(self));
     }
 }
@@ -303,7 +304,7 @@ impl TreeElement for BitfieldsContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {
+    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.sp_brace.check(acc, SpBracesArgs::from_bitfields_content(self));
     }
 }
diff --git a/src/lint/mod.rs b/src/lint/mod.rs
@@ -121,8 +121,7 @@ impl LinterAnalysis {
 
 pub fn begin_style_check(ast: TopAst, file: String, rules: &CurrentRules) -> Result<Vec<LocalDMLError>, Error> {
     let mut linting_errors: Vec<LocalDMLError> = vec![];
-    let initial_indentation: u32 = 0;
-    ast.style_check(&mut linting_errors, rules, initial_indentation);
+    ast.style_check(&mut linting_errors, rules, AuxParams { depth: 0 });      
 
     // Per line checks
     let lines: Vec<&str> = file.lines().collect();
@@ -137,6 +136,11 @@ pub fn begin_style_check(ast: TopAst, file: String, rules: &CurrentRules) -> Res
     Ok(linting_errors)
 }
 
+#[derive(Copy, Clone)]
+pub struct AuxParams {
+    pub depth: u32,
+}
+
 
 pub mod rules;
 pub mod tests {

Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,12 @@ use crate::analysis::structure::expressions::DMLString;`
`17`	`17`	`use crate::analysis::{DeclarationSpan, LocalDMLError};`
`18`	`18`
`19`	`19`
`20`		`-use crate::lint::rules::spacing::{NspFunparArgs,`
`21`		`- NspInparenArgs,`
`22`		`- NspUnaryArgs,`
`23`		`- SpPunctArgs};`
`24`		`-use crate::lint::rules::CurrentRules;`
	`20`	`+use crate::lint::{rules::{spacing::{NspFunparArgs,`
	`21`	`+ NspInparenArgs,`
	`22`	`+ NspUnaryArgs,`
	`23`	`+ SpPunctArgs},`
	`24`	`+ CurrentRules},`
	`25`	`+ AuxParams};`
`25`	`26`
`26`	`27`	`#[derive(Debug, Clone, PartialEq)]`
`27`	`28`	`pub struct UnaryExpressionContent {`
`@@ -36,7 +37,7 @@ impl TreeElement for UnaryExpressionContent {`
`36`	`37`	`fn subs(&self) -> TreeElements<'_> {`
`37`	`38`	`create_subs!(&self.operation, &self.expr)`
`38`	`39`	`}`
`39`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`40`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`40`	`41`	`rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));`
`41`	`42`	`}`
`42`	`43`	`}`
`@@ -70,7 +71,7 @@ impl TreeElement for PostUnaryExpressionContent {`
`70`	`71`	`fn subs(&self) -> TreeElements<'_> {`
`71`	`72`	`create_subs!(&self.expr, &self.operation)`
`72`	`73`	`}`
`73`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`74`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`74`	`75`	`rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));`
`75`	`76`	`}`
`76`	`77`	`}`
`@@ -208,7 +209,7 @@ impl TreeElement for FunctionCallContent {`
`208`	`209`	`noderef, ReferenceKind::Callable));`
`209`	`210`	`}`
`210`	`211`	`}`
`211`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`212`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`212`	`213`	`rules.nsp_funpar.check(acc, NspFunparArgs::from_function_call(self));`
`213`	`214`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));`
`214`	`215`	`rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));`
`@@ -419,7 +420,7 @@ impl TreeElement for IndexContent {`
`419`	`420`	`fn subs(&self) -> TreeElements<'_> {`
`420`	`421`	`create_subs!(&self.array, &self.lbracket, &self.index, &self.rbracket)`
`421`	`422`	`}`
`422`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`423`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`423`	`424`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_index(self));`
`424`	`425`	`}`
`425`	`426`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,12 @@ use crate::analysis::parsing::misc::{Initializer, InitializerContent, CDecl,`
`21`	`21`	`ident_filter, objident_filter};`
`22`	`22`	`use crate::analysis::parsing::structure::{parse_vardecl, VarDecl};`
`23`	`23`	`use crate::analysis::LocalDMLError;`
`24`		`-use crate::lint::rules::{CurrentRules,`
	`24`	`+use crate::lint::{rules::{CurrentRules,`
`25`	`25`	`indentation::{IN3Args, IN9Args},`
`26`	`26`	`spacing::{NspInparenArgs,`
`27`	`27`	`SpBracesArgs,`
`28`		`- SpPunctArgs},`
`29`		`- };`
	`28`	`+ SpPunctArgs}},`
	`29`	`+ AuxParams};`
`30`	`30`	`use crate::vfs::TextFile;`
`31`	`31`
`32`	`32`	`fn statement_contexts(context: &ParseContext)`
`@@ -141,9 +141,9 @@ impl TreeElement for CompoundContent {`
`141`	`141`	`fn subs(&self) -> TreeElements<'_> {`
`142`	`142`	`create_subs!(&self.lbrace, &self.statements, &self.rbrace)`
`143`	`143`	`}`
`144`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {`
	`144`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`145`	`145`	`rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));`
`146`		`- rules.in3.check(acc, IN3Args::from_compound_content(self, depth));`
	`146`	`+ rules.in3.check(acc, IN3Args::from_compound_content(self, &mut aux.depth));`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`@@ -195,7 +195,7 @@ impl TreeElement for VariableDeclContent {`
`195`	`195`	`fn post_parse_sanity(&self, _file: &TextFile) -> Vec<LocalDMLError> {`
`196`	`196`	`self.decls.ensure_named()`
`197`	`197`	`}`
`198`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`198`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`199`	`199`	`rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));`
`200`	`200`	`}`
`201`	`201`	`}`
`@@ -427,7 +427,7 @@ impl TreeElement for IfContent {`
`427`	`427`	`&self.truebranch,`
`428`	`428`	`&self.elsebranch)`
`429`	`429`	`}`
`430`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`430`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`431`	`431`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));`
`432`	`432`	`}`
`433`	`433`	`}`
`@@ -1003,8 +1003,8 @@ impl TreeElement for SwitchCase {`
`1003`	`1003`	`Self::Default(default, colon) => create_subs!(default, colon),`
`1004`	`1004`	`}`
`1005`	`1005`	`}`
`1006`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {`
`1007`		`- rules.in9.check(acc, IN9Args::from_switch_case(self, depth));`
	`1006`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`1007`	`+ rules.in9.check(acc, IN9Args::from_switch_case(self, &mut aux.depth));`
`1008`	`1008`	`}`
`1009`	`1009`	`}`
`1010`	`1010`
`@@ -1715,7 +1715,7 @@ impl TreeElement for ExpressionStmtContent {`
`1715`	`1715`	`fn subs(&self) -> TreeElements<'_> {`
`1716`	`1716`	`create_subs!(&self.expression, &self.semi)`
`1717`	`1717`	`}`
`1718`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`1718`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`1719`	`1719`	`rules.sp_punct.check(acc, SpPunctArgs::from_expression_stmt(self));`
`1720`	`1720`	`}`
`1721`	`1721`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ use crate::lint::rules::spacing::{SpBracesArgs,`
`21`	`21`	`NspFunparArgs,`
`22`	`22`	`SpPunctArgs};`
`23`	`23`	`use crate::lint::rules::indentation::{IN3Args};`
`24`		`-use crate::lint::rules::CurrentRules;`
	`24`	`+use crate::lint::{rules::CurrentRules, AuxParams};`
`25`	`25`	`use crate::analysis::reference::{Reference, ReferenceKind};`
`26`	`26`	`use crate::analysis::FileSpec;`
`27`	`27`	`use crate::span::Range;`
`@@ -235,7 +235,7 @@ impl TreeElement for MethodContent {`
`235`	`235`	`}`
`236`	`236`	`errors`
`237`	`237`	`}`
`238`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`238`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`239`	`239`	`rules.nsp_funpar.check(acc, NspFunparArgs::from_method(self));`
`240`	`240`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));`
`241`	`241`	`rules.sp_punct.check(acc, SpPunctArgs::from_method(self));`
`@@ -704,9 +704,9 @@ impl TreeElement for ObjectStatementsContent {`
`704`	`704`	`create_subs!(left, vect, right)`
`705`	`705`	`}`
`706`	`706`	`}`
`707`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {`
	`707`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`708`	`708`	`rules.sp_brace.check(acc, SpBracesArgs::from_obj_stmts(self));`
`709`		`- rules.in3.check(acc, IN3Args::from_obj_stmts_content(self, depth));`
	`709`	`+ rules.in3.check(acc, IN3Args::from_obj_stmts_content(self, &mut aux.depth));`
`710`	`710`	`}`
`711`	`711`	`}`
`712`	`712`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use crate::analysis::reference::{Reference, NodeRef, MaybeIsNodeRef,`
`7`	`7`	`use crate::analysis::FileSpec;`
`8`	`8`	`use crate::analysis::structure::expressions::DMLString;`
`9`	`9`
`10`		`-use crate::lint::rules::CurrentRules;`
	`10`	`+use crate::lint::{rules::CurrentRules, AuxParams};`
`11`	`11`	`use crate::span::{Range, Span, ZeroIndexed, Position, FilePosition};`
`12`	`12`	`use crate::vfs::{Vfs as GenVfs, TextFile};`
`13`	`13`
`@@ -91,13 +91,13 @@ pub trait TreeElement {`
`91`	`91`	`self.default_references(accumulator, file);`
`92`	`92`	`}`
`93`	`93`
`94`		`- fn style_check(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, mut depth: u32) {`
`95`		`- self.evaluate_rules(acc, rules, &mut depth);`
	`94`	`+ fn style_check(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, mut aux: AuxParams) {`
	`95`	`+ self.evaluate_rules(acc, rules, &mut aux);`
`96`	`96`	`for sub in self.subs() {`
`97`		`- sub.style_check(acc, rules, depth);`
	`97`	`+ sub.style_check(acc, rules, aux);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`		`- fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _depth: &mut u32) {} // default NOOP`
	`100`	`+ fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _aux: &mut AuxParams) {} // default NOOP`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`impl <T: ?Sized + TreeElement> ReferenceContainer for T {`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`// © 2024 Intel Corporation`
`2`	`2`	`// SPDX-License-Identifier: Apache-2.0 and MIT`
`3`		`-use crate::lint::rules::{indentation::IN3Args,`
`4`		`- spacing::SpBracesArgs,`
`5`		`- CurrentRules};`
	`3`	`+use crate::lint::{rules::{indentation::IN3Args,`
	`4`	`+ spacing::SpBracesArgs,`
	`5`	`+ CurrentRules},`
	`6`	`+ AuxParams};`
`6`	`7`	`use crate::span::Range;`
`7`	`8`	`use crate::analysis::parsing::lexer::TokenKind;`
`8`	`9`	`use crate::analysis::parsing::parser::{doesnt_understand_tokens,`
`@@ -51,8 +52,8 @@ impl TreeElement for StructTypeContent {`
`51`	`52`	`}`
`52`	`53`	`errors`
`53`	`54`	`}`
`54`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {`
`55`		`- rules.in3.check(acc, IN3Args::from_struct_type_content(self, depth));`
	`55`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`56`	`+ rules.in3.check(acc, IN3Args::from_struct_type_content(self, &mut aux.depth));`
`56`	`57`	`rules.sp_brace.check(acc, SpBracesArgs::from_struct_type_content(self));`
`57`	`58`	`}`
`58`	`59`	`}`
`@@ -130,8 +131,8 @@ impl TreeElement for LayoutContent {`
`130`	`131`	`}`
`131`	`132`	`errors`
`132`	`133`	`}`
`133`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, depth: &mut u32) {`
`134`		`- rules.in3.check(acc, IN3Args::from_layout_content(self, depth));`
	`134`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`135`	`+ rules.in3.check(acc, IN3Args::from_layout_content(self, &mut aux.depth));`
`135`	`136`	`rules.sp_brace.check(acc, SpBracesArgs::from_layout_content(self));`
`136`	`137`	`}`
`137`	`138`	`}`
`@@ -303,7 +304,7 @@ impl TreeElement for BitfieldsContent {`
`303`	`304`	`}`
`304`	`305`	`errors`
`305`	`306`	`}`
`306`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _depth: &mut u32) {`
	`307`	`+ fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`307`	`308`	`rules.sp_brace.check(acc, SpBracesArgs::from_bitfields_content(self));`
`308`	`309`	`}`
`309`	`310`	`}`