merge: #10 from astrodevs-labs/feat/9-autocomplete-staging

9 - Autocomplete

Author: 0xSwapFeeder

.vscode/settings.json

@@ -10,5 +10,8 @@
     },
     // Turn off tsc task auto detection since we have the necessary tasks as npm scripts
     "typescript.tsc.autoDetect": "off",
-    "npm.packageManager": "bun"
-}
+    "npm.packageManager": "pnpm",
+    "rust-analyzer.linkedProjects": [
+        ".\\libs\\code-actions\\Cargo.toml"
+    ]
+}

Cargo.lock

@@ -34,13 +34,15 @@ fn get_ast_from_foundry_output(
         if file.file.contains("safeconsole.sol") {
             continue;
         }
-        let ast: SourceUnit = serde_json::from_value(file.clone().json).map_err(|e| {
+        let ast: Result<SourceUnit, serde_json::Error> = serde_json::from_value(file.clone().json);
+        if let Err(e) = &ast {
             error!(
                 "Error while parsing json ast in file '{}': {:?}",
                 file.file, e
             );
-            e
-        })?;
+            continue;
+        }
+        let ast = ast.unwrap();
         let out_path = &file.file;
         ast_files.push(SolidityAstFile {
             file: SolidityFile {

libs/ast-extractor/src/extract.rs

@@ -0,0 +1,6 @@
+{
+    "rust-analyzer.linkedProjects": [
+        ".\\Cargo.toml",
+        ".\\Cargo.toml"
+    ]
+}

libs/code-actions/.vscode/settings.json

@@ -1,5 +1,5 @@
 [package]
-name = "osmium-libs-solidity-references"
+name = "osmium-libs-solidity-code-actions"
 version = "0.1.0"
 edition = "2021"
 

libs/references/Cargo.toml libs/code-actions/Cargo.tomllibs/references/Cargo.toml renamed to libs/code-actions/Cargo.toml

@@ -1,12 +1,12 @@
-{
-  "name": "osmium-libs-solidity-references",
-  "license": "GNU-GPL-3.0",
-  "scripts": {
-    "build": "cargo build --release --target-dir ./target",
-    "format": "cargo fmt --all",
-    "format:check": "cargo fmt --check --all",
-    "test": "cargo test",
-    "lint": "cargo clippy --allow-dirty --allow-staged --all-targets --all-features --fix -- -D warnings",
-    "lint:check": "cargo clippy --all-targets --all-features -- -D warnings"
-  }
-}
+{
+  "name": "osmium-libs-solidity-code-actions",
+  "license": "GNU-GPL-3.0",
+  "scripts": {
+    "build": "cargo build --release --target-dir ./target",
+    "format": "cargo fmt --all",
+    "format:check": "cargo fmt --check --all",
+    "test": "cargo test",
+    "lint": "cargo clippy --allow-dirty --allow-staged --all-targets --all-features --fix -- -D warnings",
+    "lint:check": "cargo clippy --all-targets --all-features -- -D warnings"
+  }
+}

libs/references/package.json libs/code-actions/package.jsonlibs/references/package.json renamed to libs/code-actions/package.json

@@ -0,0 +1,64 @@
+use crate::completions::auto_complete_provider::AutoCompleteProvider;
+use crate::error::CodeActionError;
+use crate::references::reference_provider::ReferenceProvider;
+use crate::types::{CompletionItem, Location, Position};
+use osmium_libs_solidity_ast_extractor::extract::extract_ast_from_foundry;
+use osmium_libs_solidity_ast_extractor::types::SolidityAstFile;
+use std::sync::RwLock;
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct CodeActionsProvider {
+    pub files: Arc<Mutex<Vec<SolidityAstFile>>>,
+    pub base_path: RwLock<String>,
+}
+
+impl Default for CodeActionsProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CodeActionsProvider {
+    pub fn new() -> Self {
+        Self {
+            files: Arc::new(Mutex::new(vec![])),
+            base_path: RwLock::new(String::new()),
+        }
+    }
+
+    pub fn set_base_path(&self, base_path: String) {
+        let mut r = self.base_path.write().unwrap();
+        *r = base_path;
+    }
+
+    pub fn update_file_content(&self) -> Result<(), CodeActionError> {
+        let new_files = extract_ast_from_foundry(&self.base_path.read().unwrap())?; // will always find the root foundry project
+        let mut files = self.files.lock().unwrap();
+        *files = new_files;
+        Ok(())
+    }
+
+    pub fn get_references(&self, uri: &str, position: Position) -> Vec<Location> {
+        let files = self.files.lock().unwrap();
+        let provider = ReferenceProvider::new();
+        provider.get_references(uri, position, &files)
+    }
+
+    pub fn get_definition(&self, uri: &str, position: Position) -> Option<Location> {
+        let files = self.files.lock().unwrap();
+        let provider = ReferenceProvider::new();
+        provider.get_definition(
+            uri,
+            position,
+            &files,
+            self.base_path.read().unwrap().as_str(),
+        )
+    }
+
+    pub fn get_completions(&self, uri: &str, position: Position) -> Vec<CompletionItem> {
+        let files = self.files.lock().unwrap();
+        let provider = AutoCompleteProvider::new();
+        provider.get_suggestions(uri, position, &files)
+    }
+}

libs/code-actions/src/code_actions_provider.rs

@@ -0,0 +1,5 @@
+pub mod auto_complete_provider;
+mod imports_completion_visitor;
+mod inheritence_completion_visitor;
+mod position_scope_visitor;
+mod spi_completion_provider;

libs/code-actions/src/completions.rs

@@ -0,0 +1,106 @@
+use osmium_libs_solidity_ast_extractor::types::SolidityAstFile;
+use solc_ast_rs_types::types::{ContractDefinition, ImportDirective};
+
+use crate::{
+    completions::{
+        position_scope_visitor::PositionScopeVisitor,
+        spi_completion_provider::SPICompletionProvider,
+    },
+    types::{self, CompletionItem},
+    Position,
+};
+
+use super::{
+    imports_completion_visitor::ImportCompletionVisitor,
+    inheritence_completion_visitor::InheritenceCompletionVisitor,
+};
+
+pub struct AutoCompleteProvider {}
+
+impl AutoCompleteProvider {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn while_inherits(
+        &self,
+        contract: &ContractDefinition,
+        root_file: &SolidityAstFile,
+        files: &Vec<SolidityAstFile>,
+    ) -> Vec<CompletionItem> {
+        let mut complete_finder = InheritenceCompletionVisitor::new(contract.clone());
+        let mut completes: Vec<CompletionItem> = vec![];
+        let mut inheritences = vec![contract.clone()];
+
+        while let Some(current) = inheritences.pop() {
+            // info!("Current contract to search for inheritence: {:?}", current.name);
+            for file in files {
+                let (items, inheritences_res) = complete_finder.find(
+                    &file.ast,
+                    root_file.file.path == file.file.path,
+                    current.clone(),
+                );
+                completes.append(&mut items.clone());
+                inheritences.append(&mut inheritences_res.clone());
+            }
+        }
+        completes
+    }
+
+    fn get_import_completes(
+        &self,
+        imports: Vec<ImportDirective>,
+        files: &Vec<SolidityAstFile>,
+    ) -> Vec<CompletionItem> {
+        let mut completes: Vec<CompletionItem> = vec![];
+        let mut imports_to_check: Vec<ImportDirective> = vec![];
+        for import in imports {
+            if import.unit_alias.is_empty() && import.symbol_aliases.is_empty() {
+                imports_to_check.push(import);
+            } else if import.unit_alias.is_empty() {
+                for symbol in import.symbol_aliases {
+                    completes.push(CompletionItem {
+                        label: symbol.foreign.name.clone(),
+                        kind: types::CompletionItemKind::MODULE,
+                    });
+                }
+            } else {
+                completes.push(CompletionItem {
+                    label: import.unit_alias.clone(),
+                    kind: types::CompletionItemKind::MODULE,
+                });
+            }
+        }
+        let mut import_finder = ImportCompletionVisitor::new(imports_to_check.clone());
+        let files = import_finder.get_files_from_imports(files);
+        for file in files {
+            completes.append(&mut import_finder.find(&file.ast));
+        }
+        completes
+    }
+
+    pub fn get_suggestions(
+        &self,
+        uri: &str,
+        position: Position,
+        files: &Vec<SolidityAstFile>,
+    ) -> Vec<CompletionItem> {
+        if let Some(file) = files.iter().find(|file| file.file.path == uri) {
+            let mut scope_finder = PositionScopeVisitor::new(file.file.content.clone(), position);
+            let (contract, spi, imports) = scope_finder.find(&file.ast);
+            let mut completes: Vec<CompletionItem> = vec![];
+
+            if let Some(contract) = contract {
+                completes.append(&mut self.while_inherits(&contract, file, files));
+            }
+
+            let spi_finder = SPICompletionProvider::new(spi);
+            completes.append(&mut spi_finder.inspect());
+
+            completes.append(&mut self.get_import_completes(imports, files));
+
+            return completes;
+        }
+        vec![]
+    }
+}