49 - Solidity Linter

.github/workflows/detect-workspace-changes.yml

@@ -75,24 +75,62 @@ jobs:
             console.log(workspaces)
             const affectedWorkspaces = workspaces.filter(workspace => {
               return workspace.location !== '.'
+            }).map(workspace => {
+              return {
+                name: workspace.name
+              }
             })
             console.log(affectedWorkspaces)
             const toolchainsWorkspaces = affectedWorkspaces.filter(workspace => {
               return workspace.name.startsWith('@osmium-toolchains/')
-            })
+            }).map(workspace => ({
+                name: workspace.name
+            }))
             const librariesWorkspaces = affectedWorkspaces.filter(workspace => {
               return workspace.name.startsWith('@osmium-libs/')
-            })
+            }).map(workspace => ({
+                name: workspace.name
+            }))
             const packagesWorkspaces = affectedWorkspaces.filter(workspace => {
               return workspace.name.startsWith('@osmium-packages/')
-            })
+            }).map(workspace => ({
+                name: workspace.name
+            }))
             const extensionsWorkspaces = affectedWorkspaces.filter(workspace => {
               return workspace.name.match(/@osmium\/(?:manager|(?!\w+-\w+-\w+)(?:\w+-\w+))/)
+            }).map(workspace => ({
+                name: workspace.name
+            }))
+            const extensionsFoldersWorkspaces = affectedWorkspaces.filter(workspace => {
+              return workspace.name.match(/@osmium\/\w+-\w+-\w+/)
+            }).map(workspace => ({
+                name: workspace.name
+            }))
+
+            const missingExtensionsWorkspaces = extensionsFoldersWorkspaces.map(workspaceFolder => {
+              const extensionName = workspaceFolder.name.split('-').slice(0, 2).join('-')
+              const extensionWorkspace = extensionsWorkspaces.find(workspace => {
+                return workspace.name === extensionName
+              })
+              if (!extensionWorkspace) {
+                return {
+                  name: extensionName
+                }
+              }
+              return extensionWorkspace
             })
+
+            const completeList = [...extensionsWorkspaces, ...missingExtensionsWorkspaces]
+            const completeExtensionsWorkspaces = completeList.filter((workspace, index, self) => {
+              return index === self.findIndex((t) => (
+                t.name === workspace.name
+              ))
+            })
+
             return {
               affectedWorkspaces,
               toolchainsWorkspaces,
-              extensionsWorkspaces,
+              extensionsWorkspaces: completeExtensionsWorkspaces,
               librariesWorkspaces,
               packagesWorkspaces
             }

libs/ast-extractor/src/errors.rs

@@ -0,0 +1,11 @@
+use proc_macro2::LexError;
+use syn::Error;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ExtractError {
+    #[error("Tokenization error: {0}")]
+    Tokenize(#[from] LexError),
+    #[error("Parsing error")]
+    Parse(#[from] Error),
+}

libs/ast-extractor/src/extract.rs

@@ -1,23 +1,14 @@
-use proc_macro2::{LexError, TokenStream};
 /**
  * extract.rs
  * Extract AST from solidity source code
  * author: 0xMemoryGrinder
-*/
+ */
+use crate::errors::ExtractError;
+use proc_macro2::TokenStream;
 use std::str::FromStr;
-use syn::Error;
-use thiserror::Error;
 
-#[derive(Error, Debug)]
-pub enum ExtractError {
-    #[error("Tokenization error: {0}")]
-    Tokenize(#[from] LexError),
-    #[error("Parsing error")]
-    Parse(#[from] Error),
-}
-
-pub fn extract_ast_from(source: String) -> Result<syn_solidity::File, ExtractError> {
-    let tokens = TokenStream::from_str(source.as_str())?;
+pub fn extract_ast_from_content(content: &str) -> Result<syn_solidity::File, ExtractError> {
+    let tokens = TokenStream::from_str(content)?;
     let ast = syn_solidity::parse2(tokens)?;
     Ok(ast)
 }
@@ -29,20 +20,20 @@ mod tests {
     use std::path::PathBuf;
 
     #[test]
-    fn test_extract_ast_from_good() {
+    fn test_extract_ast_from_content_good() {
         let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         path.push("tests");
         path.push("files");
         path.push("good.sol");
         let source = fs::read_to_string(path).unwrap();
-        let res = extract_ast_from(source);
+        let res = extract_ast_from_content(&source);
         assert!(res.is_ok());
     }
 
     #[test]
-    fn test_extract_ast_from_invalid_token() {
+    fn test_extract_ast_from_content_invalid_token() {
         let source = String::from("contract test { function test() public | uint a = 1 } }");
-        let result = extract_ast_from(source);
+        let result = extract_ast_from_content(&source);
         assert!(result.is_err());
         assert_eq!(
             result.unwrap_err().to_string(),
@@ -51,9 +42,9 @@ mod tests {
     }
 
     #[test]
-    fn test_extract_ast_from_missing_semicolumn() {
+    fn test_extract_ast_from_content_missing_semicolumn() {
         let source = String::from("contract test { function test() public { uint a = 1 } }");
-        let result = extract_ast_from(source);
+        let result = extract_ast_from_content(&source);
         assert!(result.is_err());
         assert_eq!(result.unwrap_err().to_string(), "Parsing error");
     }

libs/ast-extractor/src/lib.rs

@@ -1,2 +1,9 @@
+pub mod errors;
 pub mod extract;
 pub mod retriever;
+
+// Expose syn_solidity crate
+pub use syn_solidity::*;
+
+// Publish span location type
+pub use proc_macro2::LineColumn;

libs/ast-extractor/src/retriever.rs

@@ -1,8 +1,3 @@
-/**
- * retriever.rs
- * Module for all AST utils functions
- * author: 0xMemoryGrinder
-*/
 mod contract;
 pub use contract::*;
 

libs/ast-extractor/src/retriever/contract.rs

@@ -24,9 +24,9 @@ impl<'ast> Visit<'ast> for ContractVisitor {
     }
 }
 
-pub fn retrieve_contract_nodes(ast: syn_solidity::File) -> Vec<ItemContract> {
+pub fn retrieve_contract_nodes(ast: &syn_solidity::File) -> Vec<ItemContract> {
     let mut visitor = ContractVisitor::new();
-    visitor.visit_file(&ast);
+    visitor.visit_file(ast);
     visitor.contracts
 }
 
@@ -44,7 +44,7 @@ mod tests {
         let source = String::from("pragma solidity ^0.8.0;");
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
-        let res = retrieve_contract_nodes(ast);
+        let res = retrieve_contract_nodes(&ast);
         assert_eq!(res.len(), 0);
     }
 
@@ -58,7 +58,7 @@ mod tests {
         let source = fs::read_to_string(path).unwrap();
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
-        let res = retrieve_contract_nodes(ast);
+        let res = retrieve_contract_nodes(&ast);
         assert_eq!(res.len(), 1);
     }
 
@@ -72,7 +72,7 @@ mod tests {
         let source = fs::read_to_string(path).unwrap();
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
-        let res = retrieve_contract_nodes(ast);
+        let res = retrieve_contract_nodes(&ast);
         assert_eq!(res.len(), 2);
     }
 }

libs/ast-extractor/src/retriever/enum.rs

@@ -38,15 +38,15 @@ impl<'ast> Visit<'ast> for EnumVisitor {
     }
 }
 
-pub fn retrieve_enums_contract_nodes(ast: syn_solidity::ItemContract) -> Vec<ItemEnum> {
+pub fn retrieve_enums_contract_nodes(ast: &syn_solidity::ItemContract) -> Vec<ItemEnum> {
     let mut visitor = EnumVisitor::new();
-    visitor.visit_item_contract(&ast);
+    visitor.visit_item_contract(ast);
     visitor.contract_enums
 }
 
-pub fn retrieve_enums_file_nodes(ast: syn_solidity::File) -> Vec<ItemEnum> {
+pub fn retrieve_enums_file_nodes(ast: &syn_solidity::File) -> Vec<ItemEnum> {
     let mut visitor = EnumVisitor::new();
-    visitor.visit_file(&ast);
+    visitor.visit_file(ast);
     visitor.file_enums
 }
 
@@ -73,7 +73,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_enums_contract_nodes(contract);
+            let res = retrieve_enums_contract_nodes(&contract);
             assert_eq!(res.len(), 0);
         } else {
             panic!("Item shouldn't have enum");
@@ -98,7 +98,7 @@ mod tests {
             .clone();
 
         if let Item::Contract(contract) = contract {
-            let res = retrieve_enums_contract_nodes(contract);
+            let res = retrieve_enums_contract_nodes(&contract);
             assert_eq!(res.len(), 1);
         } else {
             panic!("Item should have a contract");
@@ -116,7 +116,7 @@ mod tests {
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
 
-        let res = retrieve_enums_file_nodes(ast);
+        let res = retrieve_enums_file_nodes(&ast);
         assert_eq!(res.len(), 0);
     }
 
@@ -131,7 +131,7 @@ mod tests {
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
 
-        let res = retrieve_enums_file_nodes(ast);
+        let res = retrieve_enums_file_nodes(&ast);
         assert_eq!(res.len(), 1);
     }
 }

libs/ast-extractor/src/retriever/error.rs

@@ -22,9 +22,9 @@ impl<'ast> Visit<'ast> for ErrorVisitor {
     }
 }
 
-pub fn retrieve_errors_nodes(ast: syn_solidity::ItemContract) -> Vec<ItemError> {
+pub fn retrieve_errors_nodes(ast: &syn_solidity::ItemContract) -> Vec<ItemError> {
     let mut visitor = ErrorVisitor::new();
-    visitor.visit_item_contract(&ast);
+    visitor.visit_item_contract(ast);
     visitor.errors
 }
 
@@ -51,7 +51,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_errors_nodes(contract);
+            let res = retrieve_errors_nodes(&contract);
             assert_eq!(res.len(), 0);
         } else {
             panic!("Item should not have error");
@@ -76,7 +76,7 @@ mod tests {
             .clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_errors_nodes(contract);
+            let res = retrieve_errors_nodes(&contract);
             assert_eq!(res.len(), 1);
         } else {
             panic!("Item should have a contract");

libs/ast-extractor/src/retriever/event.rs

@@ -38,15 +38,15 @@ impl<'ast> Visit<'ast> for EventVisitor {
     }
 }
 
-pub fn retrieve_events_contract_nodes(ast: syn_solidity::ItemContract) -> Vec<ItemEvent> {
+pub fn retrieve_events_contract_nodes(ast: &syn_solidity::ItemContract) -> Vec<ItemEvent> {
     let mut visitor = EventVisitor::new();
-    visitor.visit_item_contract(&ast);
+    visitor.visit_item_contract(ast);
     visitor.contract_events
 }
 
-pub fn retrieve_events_file_nodes(ast: syn_solidity::File) -> Vec<ItemEvent> {
+pub fn retrieve_events_file_nodes(ast: &syn_solidity::File) -> Vec<ItemEvent> {
     let mut visitor = EventVisitor::new();
-    visitor.visit_file(&ast);
+    visitor.visit_file(ast);
     visitor.file_events
 }
 
@@ -74,7 +74,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_events_contract_nodes(contract);
+            let res = retrieve_events_contract_nodes(&contract);
             assert_eq!(res.len(), 0);
         } else {
             panic!("Item should not have event");
@@ -99,7 +99,7 @@ mod tests {
             .clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_events_contract_nodes(contract);
+            let res = retrieve_events_contract_nodes(&contract);
             assert_eq!(res.len(), 1);
         } else {
             panic!("Item should have a event");
@@ -117,7 +117,7 @@ mod tests {
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
 
-        let res = retrieve_events_file_nodes(ast);
+        let res = retrieve_events_file_nodes(&ast);
         assert_eq!(res.len(), 0);
     }
 
@@ -132,7 +132,7 @@ mod tests {
         let tokens = TokenStream::from_str(source.as_str()).unwrap();
         let ast = syn_solidity::parse2(tokens).unwrap();
 
-        let res = retrieve_events_file_nodes(ast);
+        let res = retrieve_events_file_nodes(&ast);
         assert_eq!(res.len(), 1);
     }
 }

libs/ast-extractor/src/retriever/function.rs

@@ -24,9 +24,9 @@ impl<'ast> Visit<'ast> for FunctionVisitor {
     }
 }
 
-pub fn retrieve_functions_nodes(ast: syn_solidity::ItemContract) -> Vec<ItemFunction> {
+pub fn retrieve_functions_nodes(ast: &syn_solidity::ItemContract) -> Vec<ItemFunction> {
     let mut visitor = FunctionVisitor::new();
-    visitor.visit_item_contract(&ast);
+    visitor.visit_item_contract(ast);
     visitor.functions
 }
 
@@ -53,7 +53,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_functions_nodes(contract);
+            let res = retrieve_functions_nodes(&contract);
             assert_eq!(res.len(), 0);
         } else {
             panic!("Item is not a contract");
@@ -73,7 +73,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_functions_nodes(contract);
+            let res = retrieve_functions_nodes(&contract);
             assert_eq!(res.len(), 1);
         } else {
             panic!("Item is not a contract");
@@ -93,7 +93,7 @@ mod tests {
         let item = ast.items.first().unwrap().clone();
 
         if let Item::Contract(contract) = item {
-            let res = retrieve_functions_nodes(contract);
+            let res = retrieve_functions_nodes(&contract);
             assert_eq!(res.len(), 2);
         } else {
             panic!("Item is not a contract");