Add pointer declaration spacing rule (SP.ptrdecl) (#20)

* Add pointer declaration spacing rules

* Remove NspPtrDecl disable

Author: dtarassenko

src/analysis/parsing/misc.rs

@@ -1,3 +1,5 @@
+use crate::lint::rules::spacing::{NspPtrDeclArgs, SpPtrDeclArgs};
+use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
 use crate::span::Range;
@@ -591,6 +593,10 @@ impl TreeElement for CDeclContent {
         create_subs!(&self.consttok, &self.base,
                      &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));
+    }
 }
 
 // corresponds to cdecl in grammar

src/analysis/parsing/structure.rs

@@ -16,10 +16,7 @@ use crate::analysis::parsing::parser::{doesnt_understand_tokens,
                                        FileParser, Parse, ParseContext,
                                        FileInfo};
 use crate::analysis::LocalDMLError;
-use crate::lint::rules::spacing::{SpBracesArgs,
-                                  NspInparenArgs,
-                                  NspFunparArgs,
-                                  SpPunctArgs};
+use crate::lint::rules::spacing::{NspFunparArgs, NspInparenArgs, SpBracesArgs, SpPunctArgs};
 use crate::lint::rules::indentation::{IndentCodeBlockArgs, IndentClosingBraceArgs, IndentParenExprArgs};
 use crate::lint::{rules::CurrentRules, AuxParams, DMLStyleError};
 use crate::analysis::reference::{Reference, ReferenceKind};

src/lint/mod.rs

@@ -2,6 +2,7 @@ use std::fmt;
 use std::fs;
 use std::path::{Path, PathBuf};
 use log::{debug, error, trace};
+use rules::spacing::{SpPtrDeclOptions, NspPtrDeclOptions};
 use serde::{Deserialize, Serialize};
 use rules::{instantiate_rules, CurrentRules, RuleType};
 use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,
@@ -50,6 +51,10 @@ pub struct LintCfg {
     #[serde(default)]
     pub sp_punct: Option<SpPunctOptions>,
     #[serde(default)]
+    pub sp_ptrdecl: Option<SpPtrDeclOptions>,
+    #[serde(default)]
+    pub nsp_ptrdecl: Option<NspPtrDeclOptions>,
+    #[serde(default)]
     pub nsp_funpar: Option<NspFunparOptions>,
     #[serde(default)]
     pub nsp_inparen: Option<NspInparenOptions>,
@@ -80,6 +85,8 @@ impl Default for LintCfg {
         LintCfg {
             sp_brace: Some(SpBraceOptions{}),
             sp_punct: Some(SpPunctOptions{}),
+            sp_ptrdecl: Some(SpPtrDeclOptions{}),
+            nsp_ptrdecl: Some(NspPtrDeclOptions{}),
             nsp_funpar: Some(NspFunparOptions{}),
             nsp_inparen: Some(NspInparenOptions{}),
             nsp_unary: Some(NspUnaryOptions{}),

src/lint/rules/mod.rs

@@ -4,16 +4,16 @@ pub mod indentation;
 #[cfg(test)]
 pub mod tests;
 
-use spacing::{SpBracesRule,
-    SpPunctRule, NspFunparRule, NspInparenRule,
-    NspUnaryRule, NspTrailingRule};
+use spacing::{NspFunparRule, NspInparenRule, NspTrailingRule, NspUnaryRule, SpBracesRule, SpPtrDeclRule, NspPtrDeclRule, SpPunctRule};
 use indentation::{LongLinesRule, IndentNoTabRule, IndentCodeBlockRule, IndentClosingBraceRule, IndentParenExprRule, IndentSwitchCaseRule, IndentEmptyLoopRule};
 use crate::lint::{LintCfg, DMLStyleError};
 use crate::analysis::{LocalDMLError, parsing::tree::ZeroRange};
 
 pub struct CurrentRules {
     pub sp_brace: SpBracesRule,
     pub sp_punct: SpPunctRule,
+    pub sp_ptrdecl: SpPtrDeclRule,
+    pub nsp_ptrdecl: NspPtrDeclRule,
     pub nsp_funpar: NspFunparRule,
     pub nsp_inparen: NspInparenRule,
     pub nsp_unary: NspUnaryRule,
@@ -31,6 +31,8 @@ pub fn  instantiate_rules(cfg: &LintCfg) -> CurrentRules {
     CurrentRules {
         sp_brace: SpBracesRule { enabled: cfg.sp_brace.is_some() },
         sp_punct: SpPunctRule { enabled: cfg.sp_punct.is_some() },
+        sp_ptrdecl: SpPtrDeclRule { enabled: cfg.sp_ptrdecl.is_some() },
+        nsp_ptrdecl: NspPtrDeclRule { enabled: cfg.nsp_ptrdecl.is_some() },
         nsp_funpar: NspFunparRule { enabled: cfg.nsp_funpar.is_some() },
         nsp_inparen: NspInparenRule { enabled: cfg.nsp_inparen.is_some() },
         nsp_unary: NspUnaryRule { enabled: cfg.nsp_unary.is_some() },
@@ -65,6 +67,8 @@ pub trait Rule {
 pub enum RuleType {
     SpBraces,
     SpPunct,
+    SpPtrDecl,
+    NspPtrDecl,
     NspFunpar,
     NspInparen,
     NspUnary,

src/lint/rules/spacing.rs

@@ -1,11 +1,13 @@
 use itertools::izip;
 use std::convert::TryInto;
 use serde::{Deserialize, Serialize};
+use crate::analysis::parsing::lexer::TokenKind;
+use crate::analysis::parsing::misc::CDeclContent;
 use crate::analysis::parsing::types::{BitfieldsContent, LayoutContent,
                                       StructTypeContent};
 use crate::lint::{rules::{Rule, RuleType},
                   DMLStyleError};
-use crate::analysis::parsing::tree::{TreeElement, ZeroRange};
+use crate::analysis::parsing::tree::{LeafToken, TreeElement, ZeroRange};
 use crate::analysis::parsing::expression::{FunctionCallContent, IndexContent,
                                            PostUnaryExpressionContent,
                                            UnaryExpressionContent};
@@ -501,3 +503,132 @@ impl Rule for NspTrailingRule {
         RuleType::NspTrailing
     }
 }
+pub struct SpPtrDeclRule {
+    pub enabled: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct SpPtrDeclOptions {}
+
+impl Rule for SpPtrDeclRule {
+    fn name() -> &'static str {
+        "SP_PTRDECL"
+    }
+    fn description() -> &'static str {
+        "There should be a space between type and * marking a pointer"
+    }
+    fn get_rule_type() -> RuleType {
+        RuleType::SpPtrDecl
+    }
+}
+
+fn has_space_between(range_left: &ZeroRange,
+    range_right: &ZeroRange) -> bool {
+    return !((range_left.row_end == range_right.row_start)
+    && (range_left.col_end == range_right.col_start))
+}
+pub struct SpPtrDeclArgs {
+    type_name_range: ZeroRange,
+    operator_ranges: Vec<ZeroRange>
+}
+
+fn extract_operator_ranges_from_cdecl(node: &CDeclContent) -> Vec<ZeroRange> {
+    node.modifiers.iter()
+            .filter_map(|m| {
+                match m {
+                    LeafToken::Actual(token) => {
+                        match token.kind {
+                            TokenKind::Multiply => Some(m.range()),
+                            _ => None
+                        }
+                    }
+                    LeafToken::Missing(_) => None
+                }
+            }).collect()
+}
+
+impl SpPtrDeclArgs {
+    pub fn from_cdecl(node: &CDeclContent) -> Option<SpPtrDeclArgs> {
+        // Check if node has a multiply token inside its modifiers
+        let operator_ranges: Vec<ZeroRange> = extract_operator_ranges_from_cdecl(node);
+        Some(SpPtrDeclArgs {
+            type_name_range: node.base.range(),
+            operator_ranges: operator_ranges,
+        })
+    }
+}
+
+impl SpPtrDeclRule {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
+        ranges: Option<SpPtrDeclArgs>) {
+        if !self.enabled { return; }
+        match ranges {
+            None => return,
+            Some(ranges) => {
+                if ranges.operator_ranges.iter().any(|op_range| {
+                    !has_space_between(&ranges.type_name_range, op_range)
+                }) {
+                    self.push_err(acc, ranges.type_name_range);
+                }
+            } 
+        }
+        
+    }
+}
+
+pub struct NspPtrDeclRule {
+    pub enabled: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct NspPtrDeclOptions {}
+
+pub struct NspPtrDeclArgs {
+    rightmost_multiply: Option<ZeroRange>,
+    identifier_range: ZeroRange
+}
+
+impl NspPtrDeclArgs {
+    pub fn from_cdecl(node: &CDeclContent) -> Option<NspPtrDeclArgs> {
+        // Check if node has a multiply token inside its modifiers
+        let operator_ranges: Vec<ZeroRange> = extract_operator_ranges_from_cdecl(node);
+        let rightmost_multiply: Option<ZeroRange> = operator_ranges.last().cloned();
+        Some(NspPtrDeclArgs {
+            rightmost_multiply: rightmost_multiply,
+            identifier_range: node.decl.range()
+        })
+    }
+}
+
+impl Rule for NspPtrDeclRule {
+    fn name() -> &'static str {
+        "NSP_PTRDECL"
+    }
+    fn description() -> &'static str {
+        "There should be no space after the * marking a pointer in a declaration"
+    }
+    fn get_rule_type() -> RuleType {
+        RuleType::NspPtrDecl
+    }
+}
+
+impl NspPtrDeclRule {
+    pub fn check(&self, acc: &mut Vec<DMLStyleError>,
+        ranges: Option<NspPtrDeclArgs>) {
+        if !self.enabled { return; }
+        match ranges {
+            None => return,
+            Some(ranges) => {
+                match ranges.rightmost_multiply{
+                    None => return,
+                    Some(op_range) => {
+                        if has_space_between(&op_range, &ranges.identifier_range) {
+                            self.push_err(acc, ranges.identifier_range);
+                        }
+                    }
+                }
+            } 
+        }
+        
+    }
+}

src/lint/rules/tests/spacing/mod.rs

@@ -1,8 +1,13 @@
+use crate::lint::rules::tests::common::assert_snippet;
+use crate::lint::rules::instantiate_rules;
+use crate::lint::LintCfg;
 mod nsp_funpar;
 mod nsp_inparen;
+mod nsp_ptrdecl;
 mod nsp_trailing;
 mod nsp_unary;
 mod sp_braces;
+mod sp_ptrdecl;
 mod sp_punct;
 
 // Put whitespace (space or newline):

src/lint/rules/tests/spacing/nsp_ptrdecl.rs

@@ -0,0 +1,83 @@
+use crate::lint::rules::tests::common::{set_up, assert_snippet};
+use crate::lint::rules::RuleType;
+
+#[allow(dead_code)]
+static NSP_PTRDECL_CORRECT: &str = "
+method this_is_some_method(conf_object_t *dummy_obj) {
+    if(!dummy_obj) {
+        return;
+    }
+}";
+
+#[allow(dead_code)]
+static NSP_PTRDECL_INCORRECT_PARAM: &str = "
+method this_is_some_method(conf_object_t * dummy_obj) {
+    if(!dummy_obj) {
+        return;
+    }
+}";
+
+#[allow(dead_code)]
+static NSP_PTRDECL_INCORRECT_STATEMENT: &str = "
+method this_is_some_method(conf_object_t *dummy_obj) {
+    local conf_object_t * conf = dummy_obj;
+    if(!conf) {
+        return;
+    }
+}";
+
+#[allow(dead_code)]
+static NSP_PTRDECL_MULTIPLE_POINTER_SYMBOLS: &str = "
+method this_is_some_method(conf_object_t **dummy_obj) {
+    local conf_object_t ** conf = dummy_obj;
+    if(!conf) {
+        return;
+    }
+}";
+
+#[test]
+fn nsp_ptrdecl_correct() {
+    let mut rules = set_up();
+    assert_snippet(NSP_PTRDECL_CORRECT, vec![], &rules);
+    // Test rule disable
+    rules.nsp_ptrdecl.enabled = false;
+    assert_snippet(NSP_PTRDECL_CORRECT, vec![], &rules);
+}
+
+#[test]
+fn nsp_ptrdcl_incorrect_param() {
+    let mut rules = set_up();
+    let expected_errors = define_expected_errors!(
+        RuleType::SpPtrDecl,
+        (1, 1, 43, 52),
+    );
+    assert_snippet(NSP_PTRDECL_INCORRECT_PARAM, expected_errors, &rules);
+    // Test rule disable
+    rules.nsp_ptrdecl.enabled = false;
+    assert_snippet(NSP_PTRDECL_INCORRECT_PARAM, vec![], &rules);
+}
+#[test]
+fn nsp_ptrdecl_incorrect_statement() {
+    let mut rules = set_up();
+    let expected_errors = define_expected_errors!(
+        RuleType::NspPtrDecl,
+        (2, 2, 26, 30),
+    );
+    assert_snippet(NSP_PTRDECL_INCORRECT_STATEMENT, expected_errors, &rules);
+    // Test rule disable
+    rules.nsp_ptrdecl.enabled = false;
+    assert_snippet(NSP_PTRDECL_INCORRECT_STATEMENT, vec![], &rules);
+}
+
+#[test]
+fn nsp_ptrdecl_multiple_symbols() {
+    let mut rules = set_up();
+    let expected_errors = define_expected_errors!(
+        RuleType::NspPtrDecl,
+        (2, 2, 27, 31),
+    );
+    assert_snippet(NSP_PTRDECL_MULTIPLE_POINTER_SYMBOLS, expected_errors, &rules);
+    // Test rule disable
+    rules.nsp_ptrdecl.enabled = false;
+    assert_snippet(NSP_PTRDECL_MULTIPLE_POINTER_SYMBOLS, vec![], &rules);
+}