Wrap LocalDMLError in DMLStyleError to hold local Lint module info

jvsqzj · jvsqzj · commit 581e2ad09433 · 2025-03-14T14:42:49.000-06:00
diff --git a/src/analysis/parsing/expression.rs b/src/analysis/parsing/expression.rs
@@ -17,7 +17,8 @@ use crate::analysis::structure::expressions::DMLString;
 use crate::analysis::{DeclarationSpan, LocalDMLError};
 
 
-use crate::lint::{rules::{spacing::{NspFunparArgs,
+use crate::lint::{DMLStyleError,
+                  rules::{spacing::{NspFunparArgs,
                                     NspInparenArgs,
                                     NspUnaryArgs,
                                     SpPunctArgs},
@@ -37,7 +38,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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));
     }
 }
@@ -71,7 +72,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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));
     }
 }
@@ -209,7 +210,7 @@ impl TreeElement for FunctionCallContent {
                 noderef, ReferenceKind::Callable));
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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));
@@ -420,7 +421,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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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,7 +21,8 @@ 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::{DMLStyleError,
+                  rules::{CurrentRules,
                          indentation::{IN3Args, IN9Args},
                          spacing::{NspInparenArgs,
                                    SpBracesArgs,
@@ -141,7 +142,7 @@ 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, aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {
         rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));
         rules.in3.check(acc, IN3Args::from_compound_content(self, &mut aux.depth));
     }
@@ -195,7 +196,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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));
     }
 }
@@ -427,7 +428,7 @@ impl TreeElement for IfContent {
                      &self.truebranch,
                      &self.elsebranch)
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {
         rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));
     }
 }
@@ -1003,7 +1004,7 @@ impl TreeElement for SwitchCase {
             Self::Default(default, colon) => create_subs!(default, colon),
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {
         rules.in9.check(acc, IN9Args::from_switch_case(self, &mut aux.depth));
     }
 }
@@ -1715,7 +1716,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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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, AuxParams};
+use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};
 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, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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,7 +704,7 @@ impl TreeElement for ObjectStatementsContent {
                 create_subs!(left, vect, right)
         }
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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, &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, AuxParams};
+use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};
 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 aux: AuxParams) {
+    fn style_check(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, mut aux: AuxParams) {
         self.evaluate_rules(acc, rules, &mut aux);
         for sub in self.subs() {
             sub.style_check(acc, rules, aux);
         }
     }
-    fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _aux: &mut AuxParams) {} // default NOOP
+    fn evaluate_rules(&self, _acc: &mut Vec<DMLStyleError>, _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
@@ -3,7 +3,8 @@
 use crate::lint::{rules::{indentation::IN3Args,
                             spacing::SpBracesArgs,
                             CurrentRules},
-                            AuxParams};
+                            AuxParams,
+                            DMLStyleError};
 use crate::span::Range;
 use crate::analysis::parsing::lexer::TokenKind;
 use crate::analysis::parsing::parser::{doesnt_understand_tokens,
@@ -52,7 +53,7 @@ impl TreeElement for StructTypeContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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));
     }
@@ -131,7 +132,7 @@ impl TreeElement for LayoutContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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));
     }
@@ -304,7 +305,7 @@ impl TreeElement for BitfieldsContent {
         }
         errors
     }
-    fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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
@@ -91,6 +91,11 @@ impl Default for LintCfg {
     }
 }
 
+pub struct DMLStyleError {
+    pub error: LocalDMLError,
+    pub rule_name: String,
+}
+
 #[derive(Debug, Clone)]
 pub struct LinterAnalysis {
     pub path: CanonPath,
@@ -128,7 +133,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 mut linting_errors: Vec<DMLStyleError> = vec![];
     ast.style_check(&mut linting_errors, rules, AuxParams { depth: 0 });      
 
     // Per line checks
@@ -144,21 +149,21 @@ pub fn begin_style_check(ast: TopAst, file: String, rules: &CurrentRules) -> Res
 
     post_process_linting_errors(&mut linting_errors);
 
-    Ok(linting_errors)
+    Ok(linting_errors.into_iter().map(|e| e.error).collect())
 }
 
-fn post_process_linting_errors(errors: &mut Vec<LocalDMLError>) {
+fn post_process_linting_errors(errors: &mut Vec<DMLStyleError>) {
     // Collect in2 ranges
     let in2_ranges: Vec<_> = errors.iter()
-        .filter(|error| error.description == IN2Rule::description())
-        .map(|error| error.range)
+        .filter(|style_err| style_err.rule_name == IN2Rule::name())
+        .map(|style_err| style_err.error.range)
         .collect();
 
     // Remove linting errors that are in in2 rows
-    errors.retain(|error| {
+    errors.retain(|style_err| {
         !in2_ranges.iter().any(|range|
-            (range.row_start == error.range.row_start || range.row_end == error.range.row_end)
-            && error.description != IN2Rule::description())
+            (range.row_start == style_err.error.range.row_start || range.row_end == style_err.error.range.row_end)
+            && style_err.rule_name != IN2Rule::name())
     });
 }
 
diff --git a/src/lint/rules/indentation.rs b/src/lint/rules/indentation.rs
@@ -8,7 +8,7 @@ use crate::analysis::LocalDMLError;
 use crate::analysis::parsing::tree::{ZeroRange, Content, TreeElement};
 use serde::{Deserialize, Serialize};
 use super::Rule;
-use crate::lint::LintCfg;
+use crate::lint::{LintCfg, DMLStyleError};
 
 pub const MAX_LENGTH_DEFAULT: u32 = 80;
 pub const INDENTATION_LEVEL_DEFAULT: u32 = 4;
@@ -56,16 +56,19 @@ impl LongLinesRule {
             },
         }
     }
-    pub fn check(&self, acc: &mut Vec<LocalDMLError>, row: usize, line: &str) {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {
         if !self.enabled { return; }
         let len = line.len().try_into().unwrap();
         if len > self.max_length {
             let rowu32 = row.try_into().unwrap();
             let msg = LongLinesRule::description().to_owned()
                 + format!(" of {} characters", self.max_length).as_str();
-            let dmlerror = LocalDMLError {
-                range: Range::<ZeroIndexed>::from_u32(rowu32, rowu32, self.max_length, len),
-                description: msg,
+            let dmlerror = DMLStyleError {
+                error: LocalDMLError {
+                    range: Range::<ZeroIndexed>::from_u32(rowu32, rowu32, self.max_length, len),
+                    description: msg,
+                },
+                rule_name: Self::name().to_string(),
             };
             acc.push(dmlerror);
         }
@@ -93,16 +96,19 @@ pub struct IN2Rule {
 }
 
 impl IN2Rule {
-    pub fn check(&self, acc: &mut Vec<LocalDMLError>, row: usize, line: &str) {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>, row: usize, line: &str) {
         if !self.enabled { return; }
         let rowu32 = row.try_into().unwrap();
 
         for (col, _) in line.match_indices('\t') {
             let colu32 = col.try_into().unwrap();
             let msg = IN2Rule::description().to_owned();
-            let dmlerror = LocalDMLError {
-                range: Range::<ZeroIndexed>::from_u32(rowu32, rowu32, colu32, colu32 + 1),
-                description: msg,
+            let dmlerror = DMLStyleError {
+                error: LocalDMLError {
+                    range: Range::<ZeroIndexed>::from_u32(rowu32, rowu32, colu32, colu32 + 1),
+                    description: msg,
+                },
+                rule_name: Self::name().to_string(),
             };
             acc.push(dmlerror);
         }
@@ -187,7 +193,7 @@ impl IN3Rule {
             }
         }
     }
-    pub fn check<'a>(&self, acc: &mut Vec<LocalDMLError>,
+    pub fn check<'a>(&self, acc: &mut Vec<DMLStyleError>,
         args: Option<IN3Args<'a>>)
     {
         if !self.enabled { return; }
@@ -197,9 +203,12 @@ impl IN3Rule {
         *args.expected_depth += 1;
         for member_range in args.members_ranges {
             if self.indentation_is_not_aligned(member_range, *args.expected_depth) {
-                let dmlerror = LocalDMLError {
-                    range: member_range,
-                    description: Self::description().to_string(),
+                let dmlerror = DMLStyleError {
+                    error: LocalDMLError {
+                        range: member_range,
+                        description: Self::description().to_string(),
+                    },
+                    rule_name: Self::name().to_string(),
                 };
                 acc.push(dmlerror);
             }
@@ -248,7 +257,7 @@ impl IN6Rule {
         }
     }
 
-    pub fn check(&self, acc: &mut Vec<LocalDMLError>, lines: &[&str]) {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>, lines: &[&str]) {
         if !self.enabled {
             return;
         }
@@ -274,14 +283,17 @@ impl IN6Rule {
                         let actual_indent = next_line.chars().take_while(|c| c.is_whitespace()).count();
                         if actual_indent != expected_indent {
                             let msg = IN6Rule::description().to_owned();
-                            let dmlerror = LocalDMLError {
-                                range: Range::new(
-                                    Row::new_zero_indexed((i + 1) as u32),
-                                    Row::new_zero_indexed((i + 1) as u32),
-                                    Column::new_zero_indexed(0),
-                                    Column::new_zero_indexed(next_line.len() as u32)
-                                ),
-                                description: msg,
+                            let dmlerror = DMLStyleError {
+                                error: LocalDMLError {
+                                    range: Range::new(
+                                        Row::new_zero_indexed((i + 1) as u32),
+                                        Row::new_zero_indexed((i + 1) as u32),
+                                        Column::new_zero_indexed(0),
+                                        Column::new_zero_indexed(next_line.len() as u32)
+                                    ),
+                                    description: msg,
+                                },
+                                rule_name: Self::name().to_string(),
                             };
                             acc.push(dmlerror);
                         }
@@ -357,15 +369,18 @@ impl IN9Rule {
             }
         }
     }
-    pub fn check<'a>(&self, acc: &mut Vec<LocalDMLError>,
+    pub fn check<'a>(&self, acc: &mut Vec<DMLStyleError>,
         args: Option<IN9Args<'a>>)
     {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if self.indentation_is_not_aligned(args.case_range, *args.expected_depth) {
-            let dmlerror = LocalDMLError {
-                range: args.case_range,
-                description: Self::description().to_string(),
+            let dmlerror = DMLStyleError {
+                error: LocalDMLError {
+                    range: args.case_range,
+                    description: Self::description().to_string(),
+                },
+                rule_name: Self::name().to_string(),
             };
             acc.push(dmlerror);
         }
diff --git a/src/lint/rules/spacing.rs b/src/lint/rules/spacing.rs

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,8 @@ use crate::analysis::structure::expressions::DMLString;`
`17`	`17`	`use crate::analysis::{DeclarationSpan, LocalDMLError};`
`18`	`18`
`19`	`19`
`20`		`-use crate::lint::{rules::{spacing::{NspFunparArgs,`
	`20`	`+use crate::lint::{DMLStyleError,`
	`21`	`+ rules::{spacing::{NspFunparArgs,`
`21`	`22`	`NspInparenArgs,`
`22`	`23`	`NspUnaryArgs,`
`23`	`24`	`SpPunctArgs},`
`@@ -37,7 +38,7 @@ impl TreeElement for UnaryExpressionContent {`
`37`	`38`	`fn subs(&self) -> TreeElements<'_> {`
`38`	`39`	`create_subs!(&self.operation, &self.expr)`
`39`	`40`	`}`
`40`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`41`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`41`	`42`	`rules.nsp_unary.check(acc, NspUnaryArgs::from_unary_expr(self));`
`42`	`43`	`}`
`43`	`44`	`}`
`@@ -71,7 +72,7 @@ impl TreeElement for PostUnaryExpressionContent {`
`71`	`72`	`fn subs(&self) -> TreeElements<'_> {`
`72`	`73`	`create_subs!(&self.expr, &self.operation)`
`73`	`74`	`}`
`74`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`75`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`75`	`76`	`rules.nsp_unary.check(acc, NspUnaryArgs::from_postunary_expr(self));`
`76`	`77`	`}`
`77`	`78`	`}`
`@@ -209,7 +210,7 @@ impl TreeElement for FunctionCallContent {`
`209`	`210`	`noderef, ReferenceKind::Callable));`
`210`	`211`	`}`
`211`	`212`	`}`
`212`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`213`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`213`	`214`	`rules.nsp_funpar.check(acc, NspFunparArgs::from_function_call(self));`
`214`	`215`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));`
`215`	`216`	`rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));`
`@@ -420,7 +421,7 @@ impl TreeElement for IndexContent {`
`420`	`421`	`fn subs(&self) -> TreeElements<'_> {`
`421`	`422`	`create_subs!(&self.array, &self.lbracket, &self.index, &self.rbracket)`
`422`	`423`	`}`
`423`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`424`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`424`	`425`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_index(self));`
`425`	`426`	`}`
`426`	`427`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,8 @@ 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::{DMLStyleError,`
	`25`	`+ rules::{CurrentRules,`
`25`	`26`	`indentation::{IN3Args, IN9Args},`
`26`	`27`	`spacing::{NspInparenArgs,`
`27`	`28`	`SpBracesArgs,`
`@@ -141,7 +142,7 @@ impl TreeElement for CompoundContent {`
`141`	`142`	`fn subs(&self) -> TreeElements<'_> {`
`142`	`143`	`create_subs!(&self.lbrace, &self.statements, &self.rbrace)`
`143`	`144`	`}`
`144`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`145`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`145`	`146`	`rules.sp_brace.check(acc, SpBracesArgs::from_compound(self));`
`146`	`147`	`rules.in3.check(acc, IN3Args::from_compound_content(self, &mut aux.depth));`
`147`	`148`	`}`
`@@ -195,7 +196,7 @@ impl TreeElement for VariableDeclContent {`
`195`	`196`	`fn post_parse_sanity(&self, _file: &TextFile) -> Vec<LocalDMLError> {`
`196`	`197`	`self.decls.ensure_named()`
`197`	`198`	`}`
`198`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`199`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`199`	`200`	`rules.sp_punct.check(acc, SpPunctArgs::from_variable_decl(self));`
`200`	`201`	`}`
`201`	`202`	`}`
`@@ -427,7 +428,7 @@ impl TreeElement for IfContent {`
`427`	`428`	`&self.truebranch,`
`428`	`429`	`&self.elsebranch)`
`429`	`430`	`}`
`430`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`431`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`431`	`432`	`rules.nsp_inparen.check(acc, NspInparenArgs::from_if(self));`
`432`	`433`	`}`
`433`	`434`	`}`
`@@ -1003,7 +1004,7 @@ impl TreeElement for SwitchCase {`
`1003`	`1004`	`Self::Default(default, colon) => create_subs!(default, colon),`
`1004`	`1005`	`}`
`1005`	`1006`	`}`
`1006`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`1007`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`1007`	`1008`	`rules.in9.check(acc, IN9Args::from_switch_case(self, &mut aux.depth));`
`1008`	`1009`	`}`
`1009`	`1010`	`}`
`@@ -1715,7 +1716,7 @@ impl TreeElement for ExpressionStmtContent {`
`1715`	`1716`	`fn subs(&self) -> TreeElements<'_> {`
`1716`	`1717`	`create_subs!(&self.expression, &self.semi)`
`1717`	`1718`	`}`
`1718`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`1719`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`1719`	`1720`	`rules.sp_punct.check(acc, SpPunctArgs::from_expression_stmt(self));`
`1720`	`1721`	`}`
`1721`	`1722`	`}`
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, AuxParams};`
	`24`	`+use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};`
`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, _aux: &mut AuxParams) {`
	`238`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, 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,7 +704,7 @@ 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, aux: &mut AuxParams) {`
	`707`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`708`	`708`	`rules.sp_brace.check(acc, SpBracesArgs::from_obj_stmts(self));`
`709`	`709`	`rules.in3.check(acc, IN3Args::from_obj_stmts_content(self, &mut aux.depth));`
`710`	`710`	`}`
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, AuxParams};`
	`10`	`+use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};`
`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 aux: AuxParams) {`
	`94`	`+ fn style_check(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, mut aux: AuxParams) {`
`95`	`95`	`self.evaluate_rules(acc, rules, &mut aux);`
`96`	`96`	`for sub in self.subs() {`
`97`	`97`	`sub.style_check(acc, rules, aux);`
`98`	`98`	`}`
`99`	`99`	`}`
`100`		`- fn evaluate_rules(&self, _acc: &mut Vec<LocalDMLError>, _rules: &CurrentRules, _aux: &mut AuxParams) {} // default NOOP`
	`100`	`+ fn evaluate_rules(&self, _acc: &mut Vec<DMLStyleError>, _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
`@@ -3,7 +3,8 @@`
`3`	`3`	`use crate::lint::{rules::{indentation::IN3Args,`
`4`	`4`	`spacing::SpBracesArgs,`
`5`	`5`	`CurrentRules},`
`6`		`- AuxParams};`
	`6`	`+ AuxParams,`
	`7`	`+ DMLStyleError};`
`7`	`8`	`use crate::span::Range;`
`8`	`9`	`use crate::analysis::parsing::lexer::TokenKind;`
`9`	`10`	`use crate::analysis::parsing::parser::{doesnt_understand_tokens,`
`@@ -52,7 +53,7 @@ impl TreeElement for StructTypeContent {`
`52`	`53`	`}`
`53`	`54`	`errors`
`54`	`55`	`}`
`55`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`56`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`56`	`57`	`rules.in3.check(acc, IN3Args::from_struct_type_content(self, &mut aux.depth));`
`57`	`58`	`rules.sp_brace.check(acc, SpBracesArgs::from_struct_type_content(self));`
`58`	`59`	`}`
`@@ -131,7 +132,7 @@ impl TreeElement for LayoutContent {`
`131`	`132`	`}`
`132`	`133`	`errors`
`133`	`134`	`}`
`134`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, aux: &mut AuxParams) {`
	`135`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: &mut AuxParams) {`
`135`	`136`	`rules.in3.check(acc, IN3Args::from_layout_content(self, &mut aux.depth));`
`136`	`137`	`rules.sp_brace.check(acc, SpBracesArgs::from_layout_content(self));`
`137`	`138`	`}`
`@@ -304,7 +305,7 @@ impl TreeElement for BitfieldsContent {`
`304`	`305`	`}`
`305`	`306`	`errors`
`306`	`307`	`}`
`307`		`- fn evaluate_rules(&self, acc: &mut Vec<LocalDMLError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
	`308`	`+ fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: &mut AuxParams) {`
`308`	`309`	`rules.sp_brace.check(acc, SpBracesArgs::from_bitfields_content(self));`
`309`	`310`	`}`
`310`	`311`	`}`