wip(solidity/reference)

Author: 0xSwapFeeder

libs/solc-references/Cargo.lock

@@ -6,6 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-solc-ast-rs-types = { version = "0.1.1", features = ["visit"]}
+solc-ast-rs-types = { version = "0.1.2", features = ["visit"]}
 solc-wrapper = { path="../solc-wrapper" }
 thiserror = "1.0.56"

libs/solc-references/Cargo.toml

@@ -6,7 +6,6 @@ use crate::types::InteractableNode;
 
 struct DefinitionFinder {
     id: i64,
-    token: String,
     node: Option<InteractableNode>,
     to_find: Option<InteractableNode>,
 }
@@ -63,14 +62,15 @@ impl <'ast> Visit<'ast> for DefinitionFinder {
 }
 
 impl DefinitionFinder {
+
     pub fn new(id: i64, token: String) -> Self {
         DefinitionFinder {
             id,
-            token,
             node: None,
             to_find: None,
         }
     }
+    
     pub fn find(&mut self, src: SourceUnit) -> Option<InteractableNode> {
         self.visit_source_unit(&src);
         self.node.clone()

libs/solc-references/src/definitions.rs

@@ -8,28 +8,30 @@ mod utils;
 
 use error::ReferencesError;
 use node_finder::NodeVisitor;
-use solc_wrapper::{command::SolcCommand, get_ast_from_solc_output, SolcAstFile};
+use solc_wrapper::{get_ast_for_file, SolcAstFile};
 pub use solc_ast_rs_types::types::*;
-use types::{InteractableNode, Position};
+pub use types::{Location, Position};
+use types::{get_id, get_range, get_reference_id, InteractableNode};
 use usages::UsagesFinder;
+use utils::index_to_position;
 
-
+#[derive(Debug)]
 pub struct ReferencesProvider {
-    files: Vec<SolcAstFile>
+    pub files: Vec<SolcAstFile>
 }
 
 impl ReferencesProvider {
     pub fn update_file_content(&mut self, filepath: String, content: String) -> Result<(), ReferencesError> {
-        let solc = SolcCommand::new(filepath);
-        let out = solc.execute_with_input(&content)?;
-        let out = String::from_utf8_lossy(&out.stdout);
-        let ast_files = get_ast_from_solc_output(&out)?;
+        let ast_files = get_ast_for_file(filepath, content)?;
         for res_file in &ast_files {
             let mut found = false;
             for file in &mut self.files {
                 if file.file == res_file.file {
                     found = true;
                     file.ast = res_file.ast.clone();
+                    if res_file.src.len() > 0 {
+                        file.src = res_file.src.clone();
+                    }
                     break;
                 }
             }
@@ -40,26 +42,43 @@ impl ReferencesProvider {
         Ok(())
     }
 
-    pub fn get_references(&self, position: Position) -> Vec<(Position, Position)> {
-        let mut references: Vec<(Position, Position)> = Vec::new();
-        let mut node: InteractableNode;
-        let mut node_finder = NodeVisitor::new(position);
+    pub fn get_references(&self, position: Position) -> Vec<Location> {
+        let mut references: Vec<Location> = Vec::new();
+        let mut found_node: Option<InteractableNode> = None;
+        let mut node_finder = NodeVisitor::new(position.clone(), String::from(""));
         for file in &self.files {
-            node_finder.find(file.ast);
-            if let Some(node) = node_finder.node {
-                node = node.clone();
+            if let Some(node) = node_finder.find(&file.ast, &file.src) {
+                found_node = Some(node.clone());
+                eprintln!("Found node: {:?}", node);
                 break;
             }
         }
-        let mut usages_finder = UsagesFinder {
-            id: get_id!(node),
-            token: get_name!(node),
-            to_find: references,
+        if found_node.is_none() {
+            eprintln!("No node found at position: {:?}", &position);
+            return references;
+        }
+        let found_node = found_node.unwrap();
+        let ref_id = match get_reference_id(&found_node.clone())
+        {
+            Some(id) => id,
+            None => get_id(&found_node.clone())
         };
+
+        eprintln!("Ref id: {:?}", ref_id);
+
+        let mut usages_finder = UsagesFinder::new(ref_id);
         for file in &self.files {
             let nodes = usages_finder.find(&file.ast);
             for node in nodes {
-                references.push(node);
+                let range = get_range(&node);
+                let start = index_to_position(range.index, &file.src);
+                let end = index_to_position(range.index + range.length, &file.src);
+                let location = Location {
+                    start,
+                    end,
+                    uri: file.file.clone()
+                };
+                references.push(location);
             }
         }
         references