textrules Rename RuleResult -> SyntaxRuleResult.

dalance · May 17, 2023 · 36e4512 · 36e4512
1 parent 117bb4e
commit 36e4512
Show file tree

Hide file tree

Showing 132 changed files with 751 additions and 751 deletions.
diff --git a/src/linter.rs b/src/linter.rs
@@ -6,7 +6,7 @@ use std::path::{Path, PathBuf};
 use sv_parser::{unwrap_locate, Locate, NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Clone, Copy)]
-pub enum RuleResult {
+pub enum SyntaxRuleResult {
     Pass,
     Fail,
     FailAt(usize, usize),
@@ -19,7 +19,7 @@ pub trait SyntaxRule: Sync + Send {
         syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         config: &ConfigOption,
-    ) -> RuleResult;
+    ) -> SyntaxRuleResult;
     fn name(&self) -> String;
     fn hint(&self, config: &ConfigOption) -> String;
     fn reason(&self) -> String;
@@ -127,7 +127,7 @@ impl Linter {
             }
 
             match rule.check(syntax_tree, event, &self.option) {
-                RuleResult::Fail => {
+                SyntaxRuleResult::Fail => {
                     if let Some((path, beg)) = syntax_tree.get_origin(&locate) {
                         for exclude in &self.option.exclude_paths {
                             if exclude.is_match(&path.to_string_lossy()) {
@@ -145,7 +145,7 @@ impl Linter {
                         ret.push(result);
                     }
                 }
-                RuleResult::FailAt(offset, len) => {
+                SyntaxRuleResult::FailAt(offset, len) => {
                     if let Some((path, beg)) = syntax_tree.get_origin(&locate) {
                         for exclude in &self.option.exclude_paths {
                             if exclude.is_match(&path.to_string_lossy()) {
@@ -163,7 +163,7 @@ impl Linter {
                         ret.push(result);
                     }
                 }
-                RuleResult::FailLocate(x) => {
+                SyntaxRuleResult::FailLocate(x) => {
                     if let Some((path, beg)) = syntax_tree.get_origin(&x) {
                         for exclude in &self.option.exclude_paths {
                             if exclude.is_match(&path.to_string_lossy()) {
@@ -194,7 +194,7 @@ pub fn check_regex(
     id: Option<RefNode>,
     syntax_tree: &SyntaxTree,
     re: &Regex,
-) -> RuleResult {
+) -> SyntaxRuleResult {
     let loc: &Locate = match id {
         Some(x) => unwrap_locate!(x),
         _ => None,
@@ -204,9 +204,9 @@ pub fn check_regex(
     let is_match: bool = re.is_match(syntax_tree.get_str(loc).unwrap());
 
     if is_match == required_not_forbidden {
-        RuleResult::Pass
+        SyntaxRuleResult::Pass
     } else {
-        RuleResult::Fail
+        SyntaxRuleResult::Fail
     }
 }
 
@@ -215,7 +215,7 @@ pub fn check_prefix(
     id: Option<RefNode>,
     syntax_tree: &SyntaxTree,
     prefix: &String,
-) -> RuleResult {
+) -> SyntaxRuleResult {
     let loc: &Locate = match id {
         Some(x) => unwrap_locate!(x),
         _ => None,
@@ -225,8 +225,8 @@ pub fn check_prefix(
     let is_prefixed: bool = syntax_tree.get_str(loc).unwrap().starts_with(prefix);
 
     if is_prefixed {
-        RuleResult::Pass
+        SyntaxRuleResult::Pass
     } else {
-        RuleResult::Fail
+        SyntaxRuleResult::Fail
     }
 }
diff --git a/src/syntaxrules/action_block_with_side_effect.rs b/src/syntaxrules/action_block_with_side_effect.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use regex::Regex;
 use sv_parser::{unwrap_locate, unwrap_node, NodeEvent, RefNode, SyntaxTree};
 
@@ -14,7 +14,7 @@ impl SyntaxRule for ActionBlockWithSideEffect {
         syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         if self.re.is_none() {
             let io_tasks =
                 [ "[f]?display[bho]?" // {{{
@@ -58,7 +58,7 @@ impl SyntaxRule for ActionBlockWithSideEffect {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
 
@@ -84,12 +84,12 @@ impl SyntaxRule for ActionBlockWithSideEffect {
                 };
 
                 if let Some(loc) = loc {
-                    RuleResult::FailLocate(*loc)
+                    SyntaxRuleResult::FailLocate(*loc)
                 } else {
-                    RuleResult::Pass
+                    SyntaxRuleResult::Pass
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/blocking_assignment_in_always_ff.rs b/src/syntaxrules/blocking_assignment_in_always_ff.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{unwrap_node, AlwaysKeyword, NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -11,11 +11,11 @@ impl SyntaxRule for BlockingAssignmentInAlwaysFf {
         _syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
 
@@ -27,15 +27,15 @@ impl SyntaxRule for BlockingAssignmentInAlwaysFf {
                         let blocking_assignment = unwrap_node!(x, BlockingAssignment);
                         let variable_assignment = unwrap_node!(x, VariableDeclAssignment);
                         if blocking_assignment.is_some() || variable_assignment.is_some() {
-                            RuleResult::Fail
+                            SyntaxRuleResult::Fail
                         } else {
-                            RuleResult::Pass
+                            SyntaxRuleResult::Pass
                         }
                     }
-                    _ => RuleResult::Pass,
+                    _ => SyntaxRuleResult::Pass,
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/blocking_assignment_in_always_latch.rs b/src/syntaxrules/blocking_assignment_in_always_latch.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{unwrap_node, AlwaysKeyword, NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -11,11 +11,11 @@ impl SyntaxRule for BlockingAssignmentInAlwaysLatch {
         _syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
 
@@ -27,15 +27,15 @@ impl SyntaxRule for BlockingAssignmentInAlwaysLatch {
                         let blocking_assignment = unwrap_node!(x, BlockingAssignment);
                         let variable_assignment = unwrap_node!(x, VariableDeclAssignment);
                         if blocking_assignment.is_some() || variable_assignment.is_some() {
-                            RuleResult::Fail
+                            SyntaxRuleResult::Fail
                         } else {
-                            RuleResult::Pass
+                            SyntaxRuleResult::Pass
                         }
                     }
-                    _ => RuleResult::Pass,
+                    _ => SyntaxRuleResult::Pass,
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/case_default.rs b/src/syntaxrules/case_default.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{unwrap_locate, unwrap_node, AlwaysKeyword, NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -11,11 +11,11 @@ impl SyntaxRule for CaseDefault {
         _syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
         match node {
@@ -27,31 +27,31 @@ impl SyntaxRule for CaseDefault {
                             let loc = unwrap_locate!(x.clone()).unwrap();
                             let a = unwrap_node!(x, CaseItemDefault);
                             if a.is_some() {
-                                RuleResult::Pass
+                                SyntaxRuleResult::Pass
                             } else {
-                                RuleResult::FailLocate(*loc)
+                                SyntaxRuleResult::FailLocate(*loc)
                             }
                         } else {
-                            RuleResult::Pass
+                            SyntaxRuleResult::Pass
                         }
                     }
-                    _ => RuleResult::Pass,
+                    _ => SyntaxRuleResult::Pass,
                 }
             }
             RefNode::FunctionDeclaration(x) => {
                 if let Some(x) = unwrap_node!(*x, CaseStatementNormal) {
                     let loc = unwrap_locate!(x.clone()).unwrap();
                     let a = unwrap_node!(x, CaseItemDefault);
                     if a.is_some() {
-                        RuleResult::Pass
+                        SyntaxRuleResult::Pass
                     } else {
-                        RuleResult::FailLocate(*loc)
+                        SyntaxRuleResult::FailLocate(*loc)
                     }
                 } else {
-                    RuleResult::Pass
+                    SyntaxRuleResult::Pass
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/default_nettype_none.rs b/src/syntaxrules/default_nettype_none.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -13,11 +13,11 @@ impl SyntaxRule for DefaultNettypeNone {
         syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
 
@@ -38,12 +38,12 @@ impl SyntaxRule for DefaultNettypeNone {
             RefNode::BindDirective(_) |
             RefNode::ConfigDeclaration(_) => {
                 if self.directed_nettype == Some(String::from("none")) {
-                    RuleResult::Pass
+                    SyntaxRuleResult::Pass
                 } else {
-                    RuleResult::Fail
+                    SyntaxRuleResult::Fail
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/enum_with_type.rs b/src/syntaxrules/enum_with_type.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -11,23 +11,23 @@ impl SyntaxRule for EnumWithType {
         _syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
         match node {
             RefNode::DataTypeEnum(x) => {
                 let (_, ref a, _, _) = x.nodes;
                 if a.is_some() {
-                    RuleResult::Pass
+                    SyntaxRuleResult::Pass
                 } else {
-                    RuleResult::Fail
+                    SyntaxRuleResult::Fail
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }
 

diff --git a/src/syntaxrules/eventlist_comma_always_ff.rs b/src/syntaxrules/eventlist_comma_always_ff.rs
@@ -1,5 +1,5 @@
 use crate::config::ConfigOption;
-use crate::linter::{SyntaxRule, RuleResult};
+use crate::linter::{SyntaxRule, SyntaxRuleResult};
 use sv_parser::{unwrap_node, AlwaysKeyword, NodeEvent, RefNode, SyntaxTree};
 
 #[derive(Default)]
@@ -11,11 +11,11 @@ impl SyntaxRule for EventlistCommaAlwaysFf {
         _syntax_tree: &SyntaxTree,
         event: &NodeEvent,
         _option: &ConfigOption,
-    ) -> RuleResult {
+    ) -> SyntaxRuleResult {
         let node = match event {
             NodeEvent::Enter(x) => x,
             NodeEvent::Leave(_) => {
-                return RuleResult::Pass;
+                return SyntaxRuleResult::Pass;
             }
         };
 
@@ -26,15 +26,15 @@ impl SyntaxRule for EventlistCommaAlwaysFf {
                     AlwaysKeyword::AlwaysFf(_) => {
                         let event_expression_comma = unwrap_node!(x, EventExpressionComma);
                         if event_expression_comma.is_some() {
-                            RuleResult::Fail
+                            SyntaxRuleResult::Fail
                         } else {
-                            RuleResult::Pass
+                            SyntaxRuleResult::Pass
                         }
                     }
-                    _ => RuleResult::Pass,
+                    _ => SyntaxRuleResult::Pass,
                 }
             }
-            _ => RuleResult::Pass,
+            _ => SyntaxRuleResult::Pass,
         }
     }