Check sp_braces in more AST nodes

Author: alecalvop

src/analysis/parsing/expression.rs

@@ -177,6 +177,7 @@ impl TreeElement for ParenExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
         rules.indent_paren_expr.check(IndentParenExprArgs::from_paren_expression(self), acc);
+        rules.nsp_inparen.check( NspInparenArgs::from_paren_expression(self), acc);
     }
 }
 

src/analysis/parsing/statement.rs

@@ -1120,6 +1120,7 @@ impl TreeElement for SwitchContent {
     {
         rules.indent_closing_brace.check(IndentClosingBraceArgs::from_switch_content(self, aux.depth), acc);
         rules.indent_paren_expr.check(IndentParenExprArgs::from_switch(self), acc);
+        rules.sp_brace.check(SpBracesArgs::from_switch(self), acc);
     }
 }
 

src/analysis/parsing/structure.rs

@@ -624,6 +624,10 @@ impl TreeElement for Instantiation {
                 tok, file, ReferenceKind::Template));
         accumulator.extend(refs);
     }
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
+        rules.nsp_inparen.check(NspInparenArgs::from_instantiation(self), acc);
+        rules.sp_punct.check(SpPunctArgs::from_instantiation(self), acc);
+    }
 }
 
 fn parse_instantiation(context: &ParseContext, stream: &mut FileParser<'_>, _file_info: &FileInfo)
@@ -855,6 +859,9 @@ impl TreeElement for CompositeObjectContent {
         errors
     }
     fn references<'a>(&self, _accumulator: &mut Vec<Reference>, _file: FileSpec<'a>) {}
+    fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
+        rules.nsp_inparen.check(NspInparenArgs::from_composite_obj_content(self), acc);
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]

src/lint/rules/spacing.rs

@@ -9,14 +9,23 @@ use crate::lint::{rules::{Rule, RuleType},
                   DMLStyleError};
 use crate::analysis::parsing::tree::{LeafToken, TreeElement, ZeroRange};
 use crate::analysis::parsing::expression::{BinaryExpressionContent,
-                                           FunctionCallContent, IndexContent,
+                                           FunctionCallContent,
+                                           IndexContent,
+                                           ParenExpressionContent,
                                            PostUnaryExpressionContent,
                                            TertiaryExpressionContent,
                                            UnaryExpressionContent};
-use crate::analysis::parsing::statement::{AfterContent, CompoundContent, ExpressionStmtContent,
-                                          ForContent, IfContent, VariableDeclContent,
+use crate::analysis::parsing::statement::{AfterContent,
+                                          CompoundContent,
+                                          ExpressionStmtContent,
+                                          ForContent,
+                                          IfContent,
+                                          SwitchContent,
+                                          VariableDeclContent,
                                           WhileContent};
-use crate::analysis::parsing::structure::{MethodContent,
+use crate::analysis::parsing::structure::{CompositeObjectContent,
+                                          Instantiation,
+                                          MethodContent,
                                           ObjectStatementsContent};
 
 use crate::span::{ZeroIndexed, Range};
@@ -206,6 +215,17 @@ impl SpBracesArgs {
             rbrace: node.rbrace.range(),
         })
     }
+    pub fn from_switch(node: &SwitchContent) -> Option<SpBracesArgs> {
+        if node.cases.is_empty() {
+            return None;
+        }
+        Some(SpBracesArgs {
+            body_start: node.cases.first().unwrap().range(),
+            body_end: node.cases.last().unwrap().range(),
+            lbrace: node.lbrace.range(),
+            rbrace: node.rbrace.range(),
+        })
+    }
 }
 
 impl SpBracesRule {
@@ -465,6 +485,34 @@ impl SpPunctArgs {
             after_range_list,
         })
     }
+    pub fn from_instantiation(node: &Instantiation) -> Option<SpPunctArgs> {
+        if let Instantiation::Many(_, templates_list, _) = node {
+            let mut before_range_list = vec![];
+            let mut punct_range_list = vec![];
+            let mut after_range_list = vec![];
+            let mut iterator = templates_list.iter().peekable();
+
+            while let Some((template_name, comma)) = iterator.next() {
+                if let Some(comma_token) = comma {
+                    before_range_list.push(template_name.range());
+                    punct_range_list.push(comma_token.range());
+                    if let Some((next_template_name, _)) = iterator.peek() {
+                        after_range_list.push(Some(next_template_name.range()));
+                    } else {
+                        after_range_list.push(None);
+                    }
+                }
+            }
+
+            Some(SpPunctArgs {
+                before_range_list,
+                punct_range_list,
+                after_range_list,
+            })
+        } else {
+            None
+        }
+    }
 }
 
 impl SpPunctRule {
@@ -600,6 +648,41 @@ impl NspInparenArgs {
             closing: node.rparen.range(),
         })
     }
+    pub fn from_composite_obj_content(node: &CompositeObjectContent)
+                                            -> Option<NspInparenArgs> {
+        if node.dimensions.is_empty() {
+            return None;
+        }
+        let dimension = node.dimensions.first().unwrap();
+        Some(NspInparenArgs {
+            opening: dimension.0.range(),
+            content_start: dimension.1.range(),
+            content_end: dimension.3.range(),
+            closing: dimension.4.range(),
+        })
+    }
+    pub fn from_instantiation(node: &Instantiation)
+                              -> Option<NspInparenArgs> {
+        if let Instantiation::Many(lparen, templates, rparen) = node {
+            Some(NspInparenArgs {
+                opening: lparen.range(),
+                content_start: templates.range(),
+                content_end: templates.range(),
+                closing: rparen.range(),
+            })
+        } else {
+            None
+        }
+    }
+    pub fn from_paren_expression(node: &ParenExpressionContent)
+                              -> Option<NspInparenArgs> {
+        Some(NspInparenArgs {
+            opening: node.lparen.range(),
+            content_start: node.expr.range(),
+            content_end: node.expr.range(),
+            closing: node.rparen.range(),
+        })
+    }
     pub fn from_function_call(node: &FunctionCallContent)
                               -> Option<NspInparenArgs> {
         let content_start_range;