Files

ls_framework/Cargo.toml

@@ -11,6 +11,7 @@ indextree = "4.5.0"
 itertools = "0.11.0"
 lazy_static = "1.4.0"
 log = "0.4.19"
+petgraph = "0.6.4"
 regex = "1.7.2"
 ron = "0.8.0"
 serde = { version = "1.0.152", features = ["derive"] }
@@ -21,3 +22,4 @@ time = "0.3.20"
 tokio = { version = "1.28.2", features = ["full"] }
 tower-lsp = "0.19.0"
 tree-sitter = "0.20.9"
+walkdir = "2.4.0"

ls_framework/src/features/completion.rs

@@ -5,7 +5,7 @@
     CompletionContext, CompletionItem, CompletionItemKind, CompletionTriggerKind, Position,
 };
 
 fn default_list(
     position: Position,
     query: &Arc<Mutex<impl SymbolTableQuery>>,
 ) -> Option<Vec<CompletionItem>> {
@@ -22,7 +22,7 @@
     Some(items)
 }
 
 fn get_symbol_completion_type(symbol_kind: String) -> Option<CompletionItemKind> {
     Some(
         LanguageDefinition::get()
             .symbol_types
@@ -46,7 +46,7 @@
     }
 
     let name_field = query.lock().unwrap().get_name_field(position, source_code);
-
+    info!("cimpletion:{:?}", name_field);
     match name_field {
         Some(fields) => {
             return Some(
@@ -60,6 +60,6 @@
                     .collect(),
             )
         }
-        None => default_list(position, query),
+        None => None, //default_list(position, query),
     }
 }

ls_framework/src/features/goto.rs

@@ -3,17 +3,23 @@ use std::sync::{Arc, Mutex};
 use crate::metadata::{AstQuery, SymbolTableQuery, Visitable};
 use tower_lsp::lsp_types::{Position, Range};
 
+use crate::file_graph::FileGraph;
+use petgraph::graph::NodeIndex;
 pub fn get_definition_range(
     ast_query: &Arc<Mutex<impl AstQuery>>,
-    symbol_table_query: &Arc<Mutex<impl SymbolTableQuery>>,
+    _symbol_table_query: &Arc<Mutex<impl SymbolTableQuery>>,
+    graph: &FileGraph,
     position: Position,
-) -> Option<Range> {
+) -> Option<(Range, NodeIndex)> {
     let ast_query = ast_query.lock().unwrap();
     let root_visit = ast_query.visit_root();
     let node = root_visit.get_node_at_position(position)?;
 
-    let symbol_table_query = symbol_table_query.lock().unwrap();
-    let symbol = symbol_table_query.get_symbol(node.get().linked_symbol.clone()?)?;
+    let n = node.get().linked_symbol.clone()?;
+    let file_id = n.file_id;
+    let y = graph.get_node(n.file_id).unwrap();
+    let x = y.file.symbol_table_manager.lock().unwrap();
 
-    Some(symbol.get_definition_range())
+    let symbol = x.get_symbol(n)?;
+    Some((symbol.get_definition_range(), file_id))
 }

ls_framework/src/features/hover.rs

@@ -4,23 +4,72 @@ use tower_lsp::lsp_types::{HoverContents, MarkedString, Position};
 
 use crate::metadata::{AstQuery, SymbolTableQuery, Visitable};
 
+use crate::file_graph::FileGraph;
+
 pub fn get_hover_info(
     ast_query: &Arc<Mutex<impl AstQuery>>,
     symbol_table_query: &Arc<Mutex<impl SymbolTableQuery>>,
+    graph: &FileGraph,
     position: Position,
 ) -> Option<HoverContents> {
+    info!("Hover");
     let ast_query = ast_query.lock().unwrap();
     let root_visit = ast_query.visit_root();
     let node = root_visit.get_node_at_position(position)?;
+    let temp = {
+        let st_query = symbol_table_query.lock().unwrap();
+        let symbol = st_query.get_symbol(node.get().linked_symbol.clone()?)?;
+        symbol.get_type_symbol()
+    };
+
+    if let Some(temp1) = temp {
+        let st_query = symbol_table_query.lock().unwrap();
+        let symbol = st_query.get_symbol(node.get().linked_symbol.clone()?)?;
+        info!(
+            "Sylinkedmbol:{:?}",
+            node.get().linked_symbol.clone().unwrap()
+        );
+
+        info!("Symbol:{}", symbol);
+
+        info!("Temp Hover");
+        let type_symbol = st_query.get_symbol(temp1)?;
+        Some(HoverContents::Scalar(MarkedString::String(format!(
+            "{}: {}",
+            symbol.get_name(),
+            type_symbol.get_name()
+        ))))
+    } else {
+        info!("Added Hover");
+        let previous_name = &node.get().content;
+        let linked_symbol = node.get().linked_symbol.clone()?;
+
+        info!("A");
+
+        info!("prev:{:?}", previous_name);
+        let linked_node = graph.get_node(linked_symbol.file_id).unwrap();
+        info!("A1");
 
-    let st_query = symbol_table_query.lock().unwrap();
-    let symbol = st_query.get_symbol(node.get().linked_symbol.clone()?)?;
+        info!("preve:{:?}", linked_node);
+        let linked_manager = linked_node.file.symbol_table_manager.lock().unwrap();
+        info!("A2");
+        let binding = linked_manager.get_all_symbols();
+        info!("A3");
 
-    let type_symbol = st_query.get_symbol(symbol.get_type_symbol()?)?;
+        info!("list {:?}", binding);
+        let symbol_exist = binding.iter().find(|s| &s.get_name() == previous_name);
+        info!("A4");
+        info!("{:?}", symbol_exist);
+        let symbol = symbol_exist?;
+        info!("A5");
+        info!("{:?}", symbol);
+        info!("{:?}", symbol.get_type_symbol().unwrap());
+        let type_symbol = linked_manager.get_symbol(symbol.get_type_symbol()?)?;
 
-    Some(HoverContents::Scalar(MarkedString::String(format!(
-        "{}: {}",
-        symbol.get_name(),
-        type_symbol.get_name()
-    ))))
+        Some(HoverContents::Scalar(MarkedString::String(format!(
+            "{}: {}",
+            symbol.get_name(),
+            type_symbol.get_name()
+        ))))
+    }
 }

ls_framework/src/features/rename.rs

@@ -6,52 +6,80 @@ use std::{
 use crate::metadata::{
     AstQuery, Symbol, SymbolTableEdit, SymbolTableEditor, SymbolTableQuery, Visitable,
 };
+
+use crate::file_graph::FileGraph;
 use tower_lsp::lsp_types::{Position, TextEdit, Url, WorkspaceEdit};
 
 pub fn rename(
     ast_query: &Arc<Mutex<impl AstQuery>>,
-    symbol_table_query: &Arc<Mutex<impl SymbolTableQuery>>,
-    symbol_table_editor: &Arc<Mutex<impl SymbolTableEditor>>,
-    uri: Url,
+    _symbol_table_query: &Arc<Mutex<impl SymbolTableQuery>>,
+    _symbol_table_editor: &Arc<Mutex<impl SymbolTableEditor>>,
+    _uri: Url,
     new_name: String,
     position: Position,
+    graph: &FileGraph,
 ) -> Option<WorkspaceEdit> {
     let ast_query = ast_query.lock().unwrap();
     let root_visit = ast_query.visit_root();
     let node = root_visit.get_node_at_position(position)?;
     let previous_name = &node.get().content;
 
+    let n = node.get().linked_symbol.clone()?;
+
+    let y = graph.get_node(n.file_id).unwrap();
+    let cur_url = y.file.uri.clone();
+    let x = y.file.symbol_table_manager.lock().unwrap();
+
     debug!("previous name: {}", previous_name);
+    let mut return_changes: Option<WorkspaceEdit> = None;
+    let binding = x.get_all_symbols();
+    binding.iter().for_each(|s| info!("T:{:?}", &s.get_name()));
+    let symbol_exist = binding.iter().find(|s| &s.get_name() == previous_name);
 
-    let symbol = {
-        let query = symbol_table_query.lock().unwrap();
-        query
-            .get_symbol_at_pos(previous_name.clone(), position)?
-            .clone()
-    };
+    info!("Symbollldfddyy{:?} ", symbol_exist);
+    if let Some(symbol) = symbol_exist {
+        info!("Symbollldfddyy{:?} ", symbol);
+        let mut editor = x;
+        editor.new_edit(SymbolTableEdit::Rename {
+            symbol_id: symbol.get_id(),
+            new_name: new_name.clone(),
+        });
 
-    let mut editor = symbol_table_editor.lock().unwrap();
-    editor.new_edit(SymbolTableEdit::Rename {
-        symbol_id: symbol.get_id(),
-        new_name: new_name.clone(),
-    });
+        return_changes = Some(WorkspaceEdit::new(build_changes(
+            cur_url, symbol, new_name, graph,
+        )))
+    }
+    return_changes
 
     // TODO: Change this to utilize symbol id
-
-    Some(WorkspaceEdit::new(build_changes(uri, &symbol, new_name)))
 }
 
-fn build_changes(uri: Url, symbol: &Symbol, new_name: String) -> HashMap<Url, Vec<TextEdit>> {
+fn build_changes(
+    curr: Url,
+    symbol: &Symbol,
+    new_name: String,
+    graph: &FileGraph,
+) -> HashMap<Url, Vec<TextEdit>> {
     let mut edits: Vec<TextEdit> = Vec::new();
+    let mut map: HashMap<Url, Vec<TextEdit>> = HashMap::new();
 
     edits.push(TextEdit::new(
         symbol.get_definition_range(),
         new_name.clone(),
     ));
-
-    for range in symbol.get_usages() {
-        edits.push(TextEdit::new(*range, new_name.clone()));
+    map.insert(curr, edits);
+    for usage in symbol.get_usages() {
+        info!("Usage: {:?}", usage);
+        let url = graph
+            .find_url_from_node_index(usage.file_id.unwrap())
+            .unwrap();
+        if let Some(existing_vector) = map.get_mut(&url) {
+            existing_vector.push(TextEdit::new(usage.range, new_name.clone()));
+        } else {
+            let new_vector = vec![TextEdit::new(usage.range, new_name.clone())];
+            map.insert(url, new_vector);
+        }
     }
 
-    HashMap::from([(uri, edits)])
+    map
 }