feat(rules): adding rules ordering file, contract and visibility draft

Author: ByFishh

solidhunter-lib/src/rules/order/mod.rs

@@ -1,9 +1,13 @@
 use std::collections::HashMap;
+use crate::rules::order::ordering_contract::OrderingContract;
+use crate::rules::order::ordering_file::OrderingFile;
+use crate::rules::order::ordering_visibility::OrderingVisibility;
 use crate::rules::types::{RuleEntry, RuleType};
-use crate::rules::order::ordering::Ordering;
 
 #[macro_use]
-pub(crate) mod ordering;
+pub(crate) mod ordering_contract;
+pub(crate) mod ordering_file;
+mod ordering_visibility;
 
 // List all rules
 
@@ -12,15 +16,19 @@ use crate::rules::RuleBuilder;
 pub fn create_default_rules() -> Vec<RuleEntry> {
     let mut rules = Vec::new();
 
-    rules.push(Ordering::create_default());
+    rules.push(OrderingContract::create_default());
+    rules.push(OrderingFile::create_default());
+    rules.push(OrderingVisibility::create_default());
 
     rules
 }
 
 pub fn create_rules() -> HashMap<String, fn(RuleEntry) -> Box<dyn RuleType>> {
     let mut rules :  HashMap<String, RuleBuilder> = HashMap::new();
 
-    rules.insert( "ordering".to_string(), Ordering::create);
+    rules.insert( "ordering-contract".to_string(), OrderingContract::create);
+    rules.insert( "ordering-file".to_string(), OrderingFile::create);
+    rules.insert( "ordering-visibility".to_string(), OrderingFile::create);
 
     rules
 }

solidhunter-lib/src/rules/order/ordering.rs renamed to solidhunter-lib/src/rules/order/ordering_contract.rs

@@ -4,7 +4,7 @@ use crate::rules::types::*;
 use crate::types::*;
 use solc_wrapper::{ContractDefinitionChildNodes, ContractKind, decode_location, NodeType, SourceLocation, SourceUnit, SourceUnitChildNodes};
 
-pub struct Ordering {
+pub struct OrderingContract {
     data: RuleEntry
 }
 
@@ -14,93 +14,45 @@ pub struct Eval {
     src: SourceLocation
 }
 
-fn eval_file(source_unit_childs: &Vec<SourceUnitChildNodes>) -> Vec<Eval>{
-
-    let mut eval = Vec::new();
-
-    for node in source_unit_childs {
-        match node {
-            SourceUnitChildNodes::ErrorDefinition(error) => {
-                if error.node_type == NodeType::EnumDefinition {
-                    eval.push(Eval { weight: 1, src: error.src.clone() });
-                } else if error.node_type == NodeType::StructDefinition {
-                    eval.push(Eval { weight: 2, src: error.src.clone() });
-                }
-                //TODO: Remove this when Error definition fixed
-            }
-            SourceUnitChildNodes::EnumDefinition(tmp) => eval.push(Eval { weight: 2, src: tmp.src.clone() }),
-            SourceUnitChildNodes::StructDefinition(tmp) => eval.push(Eval { weight: 3, src: tmp.src.clone() }),
-            SourceUnitChildNodes::ContractDefinition(contract) => {
-                if contract.contract_kind == ContractKind::Interface {
-                    eval.push(Eval { weight: 3, src: contract.src.clone() });
-                } else if contract.contract_kind == ContractKind::Library {
-                    eval.push(Eval { weight: 4, src: contract.src.clone() });
-                } else {
-                    eval.push(Eval { weight: 5, src: contract.src.clone() });
-                }
-            }
-            _ => { continue; }
-        }
-    }
-
-    eval
-}
-
 fn eval_contract(contract_child_node: &Vec<ContractDefinitionChildNodes>) -> Vec<Eval>{
 
     let mut eval = Vec::new();
 
     for node in contract_child_node {
         match node {
+
+            ContractDefinitionChildNodes::UsingForDirective(tmp) => eval.push(Eval { weight: 1, src: tmp.src.clone() }),
+
             ContractDefinitionChildNodes::ErrorDefinition(tmp) => {
                 //TODO: Remove this when Error definition fixed
                 if tmp.node_type == NodeType::EnumDefinition {
                     eval.push(Eval { weight: 3, src: tmp.src.clone() });
                 } else if tmp.node_type == NodeType::StructDefinition {
                     eval.push(Eval { weight: 2, src: tmp.src.clone() });
+                } else if tmp.node_type == NodeType::EventDefinition {
+                    eval.push(Eval { weight: 5, src: tmp.src.clone() });
                 }
             },
-            ContractDefinitionChildNodes::UsingForDirective(tmp) => eval.push(Eval { weight: 1, src: tmp.src.clone() }),
             ContractDefinitionChildNodes::StructDefinition(tmp) => eval.push(Eval { weight: 2, src: tmp.src.clone() }),
             ContractDefinitionChildNodes::EnumDefinition(tmp) => eval.push(Eval { weight: 3, src: tmp.src.clone() }),
+
             ContractDefinitionChildNodes::VariableDeclaration(tmp) => eval.push(Eval { weight: 4, src: tmp.src.clone() }),
             ContractDefinitionChildNodes::EventDefinition(tmp) => eval.push(Eval { weight: 5, src: tmp.src.clone() }),
             ContractDefinitionChildNodes::ModifierDefinition(tmp) => eval.push(Eval { weight: 6, src: tmp.src.clone() }),
             ContractDefinitionChildNodes::FunctionDefinition(tmp) => eval.push(Eval { weight: 7, src: tmp.src.clone() }),
+
             _ => { continue; }
         }
     }
 
     eval
 }
 
-impl RuleType for Ordering {
+impl RuleType for OrderingContract {
 
     fn diagnose(&self, file: &SolidFile, files: &Vec<SolidFile>) -> Vec<LintDiag> {
 
         let mut res = Vec::new();
-        let eval = eval_file(&file.data.nodes);
-
-        if eval.len() > 1 {
-            for i in 0..eval.len() - 1 {
-                if eval[i].weight > eval[i + 1].weight {
-                    let location = decode_location(&eval[i].src, &file.content);
-                    res.push(LintDiag {
-                        range: Range {
-                            start: Position { line: location.0.line as u64, character: location.0.column as u64 },
-                            end: Position { line: location.1.line as u64, character: location.1.column as u64 },
-                            length: location.0.length as u64,
-                        },
-                        message: format!("File need to be ordered: Using for -> Struct -> Enum -> Variable -> Event -> Modifier -> Function"),
-                        severity: Some(self.data.severity),
-                        code: None,
-                        source: None,
-                        uri: file.path.clone(),
-                        source_file_content: file.content.clone(),
-                    });
-                }
-            }
-        }
 
         for node in &file.data.nodes {
             match node {
@@ -117,7 +69,7 @@ impl RuleType for Ordering {
                                     end: Position { line: location.1.line as u64, character: location.1.column as u64 },
                                     length: location.0.length as u64,
                                 },
-                                message: format!("Contract need to be ordered: Enum -> Struct -> Interface -> Library -> Contract"),
+                                message: format!("Contract need to be ordered: Using for -> Struct -> Enum -> Variable -> Event -> Modifier -> Function"),
                                 severity: Some(self.data.severity),
                                 code: None,
                                 source: None,
@@ -135,17 +87,17 @@ impl RuleType for Ordering {
     }
 }
 
-impl Ordering {
+impl OrderingContract {
     pub(crate) fn create(data: RuleEntry) -> Box<dyn RuleType> {
-        let mut rule  = Ordering {
+        let mut rule  = OrderingContract {
             data
         };
         Box::new(rule)
     }
 
     pub(crate) fn create_default() -> RuleEntry {
         RuleEntry {
-            id: "ordering".to_string(),
+            id: "ordering-contract".to_string(),
             severity: Severity::WARNING,
             data: vec![]
         }

solidhunter-lib/src/rules/order/ordering_file.rs

@@ -0,0 +1,121 @@
+use clap::builder::Str;
+use crate::linter::SolidFile;
+use crate::rules::types::*;
+use crate::types::*;
+use solc_wrapper::{ContractDefinitionChildNodes, ContractKind, decode_location, NodeType, SourceLocation, SourceUnit, SourceUnitChildNodes};
+
+pub struct OrderingFile {
+    data: RuleEntry
+}
+
+#[derive(Debug)]
+pub struct Eval {
+    weight: usize,
+    src: SourceLocation
+}
+
+fn eval_file(source_unit_childs: &Vec<SourceUnitChildNodes>, res: &mut Vec<LintDiag>, severity: Severity, file: &SolidFile) -> Vec<Eval>{
+
+    let mut eval = Vec::new();
+
+    for node in source_unit_childs {
+        match node {
+            SourceUnitChildNodes::ContractDefinition(contract) => {
+                if contract.contract_kind == ContractKind::Interface {
+                    eval.push(Eval { weight: 1, src: contract.src.clone() });
+                } else if contract.contract_kind == ContractKind::Library {
+                    eval.push(Eval { weight: 2, src: contract.src.clone() });
+                } else {
+                    eval.push(Eval { weight: 3, src: contract.src.clone() });
+                }
+            }
+            SourceUnitChildNodes::ErrorDefinition(error) => {
+                let location = decode_location(error.src.as_str(), &file.content);
+
+                if error.node_type == NodeType::EnumDefinition {
+                    res.push(LintDiag {
+                        range: Range {
+                            start: Position { line: location.0.line as u64, character: location.0.column as u64 },
+                            end: Position { line: location.1.line as u64, character: location.1.column as u64 },
+                            length: location.0.length as u64,
+                        },
+                        message: format!("Enum can't be outside a contract."),
+                        severity: Some(severity),
+                        code: None,
+                        source: None,
+                        uri: file.path.clone(),
+                        source_file_content: file.content.clone(),
+                    });
+                } else if error.node_type == NodeType::StructDefinition {
+                    res.push(LintDiag {
+                        range: Range {
+                            start: Position { line: location.0.line as u64, character: location.0.column as u64 },
+                            end: Position { line: location.1.line as u64, character: location.1.column as u64 },
+                            length: location.0.length as u64,
+                        },
+                        message: format!("Struct can't be outside a contract."),
+                        severity: Some(severity),
+                        code: None,
+                        source: None,
+                        uri: file.path.clone(),
+                        source_file_content: file.content.clone(),
+                    });
+                }
+                //TODO: Edit this when Error definition fixed
+            }
+            //SourceUnitChildNodes::EnumDefinition(tmp) => eval.push(Eval { weight: 2, src: tmp.src.clone() }),
+            //SourceUnitChildNodes::StructDefinition(tmp) => eval.push(Eval { weight: 3, src: tmp.src.clone() }),
+            _ => { continue; }
+        }
+    }
+
+    eval
+}
+
+impl RuleType for OrderingFile {
+    fn diagnose(&self, file: &SolidFile, files: &Vec<SolidFile>) -> Vec<LintDiag> {
+
+        let mut res = Vec::new();
+        let eval = eval_file(&file.data.nodes, &mut res, self.data.severity, file);
+
+        if eval.len() > 1 {
+            for i in 0..eval.len() - 1 {
+                if eval[i].weight > eval[i + 1].weight {
+                    let location = decode_location(&eval[i].src, &file.content);
+                    res.push(LintDiag {
+                        range: Range {
+                            start: Position { line: location.0.line as u64, character: location.0.column as u64 },
+                            end: Position { line: location.1.line as u64, character: location.1.column as u64 },
+                            length: location.0.length as u64,
+                        },
+                        message: format!("File need to be ordered: Interface -> Library -> Contract"),
+                        severity: Some(self.data.severity),
+                        code: None,
+                        source: None,
+                        uri: file.path.clone(),
+                        source_file_content: file.content.clone(),
+                    });
+                }
+            }
+        }
+
+        res
+    }
+}
+
+impl OrderingFile {
+    pub(crate) fn create(data: RuleEntry) -> Box<dyn RuleType> {
+        let mut rule  = OrderingFile {
+            data
+        };
+        Box::new(rule)
+    }
+
+    pub(crate) fn create_default() -> RuleEntry {
+        RuleEntry {
+            id: "ordering-file".to_string(),
+            severity: Severity::WARNING,
+            data: vec![]
+        }
+    }
+}