feat(lsp): allow function rename

compiler/noirc_frontend/Cargo.toml

@@ -24,6 +24,7 @@ small-ord-set = "0.1.3"
 regex = "1.9.1"
 tracing.workspace = true
 petgraph = "0.6"
+rangemap = "1.4.0"
 
 [dev-dependencies]
 strum = "0.24"

compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs

@@ -15,17 +15,20 @@ use crate::hir::type_check::{type_check_func, TypeCheckError, TypeChecker};
 use crate::hir::Context;
 
 use crate::macros_api::{MacroError, MacroProcessor};
-use crate::node_interner::{FuncId, GlobalId, NodeInterner, StructId, TraitId, TypeAliasId};
+use crate::node_interner::{
+    DependencyId, FuncId, GlobalId, NodeInterner, StructId, TraitId, TypeAliasId,
+};
 
 use crate::parser::{ParserError, SortedModule};
 use crate::{
     ExpressionKind, Ident, LetStatement, Literal, NoirFunction, NoirStruct, NoirTrait,
     NoirTypeAlias, Path, PathKind, Type, TypeBindings, UnresolvedGenerics,
     UnresolvedTraitConstraint, UnresolvedType,
 };
+
 use fm::FileId;
 use iter_extended::vecmap;
-use noirc_errors::{CustomDiagnostic, Span};
+use noirc_errors::{CustomDiagnostic, Location, Span};
 use std::collections::{BTreeMap, HashMap};
 
 use std::vec;
@@ -268,6 +271,7 @@ impl DefCollector {
 
         // Resolve unresolved imports collected from the crate, one by one.
         for collected_import in def_collector.collected_imports {
+            let module_id = collected_import.module_id;
             match resolve_import(crate_id, collected_import, &context.def_maps) {
                 Ok(resolved_import) => {
                     // Populate module namespaces according to the imports used
@@ -278,6 +282,9 @@ impl DefCollector {
                         let result = current_def_map.modules[resolved_import.module_scope.0]
                             .import(name.clone(), ns, resolved_import.is_prelude);
 
+                        let file_id = current_def_map.file_id(module_id);
+                        add_import_reference(ns, &name, &mut context.def_interner, file_id);
+
                         if let Err((first_def, second_def)) = result {
                             let err = DefCollectorErrorKind::Duplicate {
                                 typ: DuplicateType::Import,
@@ -381,6 +388,24 @@ impl DefCollector {
     }
 }
 
+fn add_import_reference(
+    def_id: crate::macros_api::ModuleDefId,
+    name: &Ident,
+    interner: &mut NodeInterner,
+    file_id: FileId,
+) {
+    if name.span() == Span::empty(0) {
+        // We ignore empty spans at 0 location, this must be Stdlib
+        return;
+    }
+    if let crate::macros_api::ModuleDefId::FunctionId(func_id) = def_id {
+        interner.add_reference_for(
+            DependencyId::Function(func_id),
+            (DependencyId::FunctionCall, Location::new(name.span(), file_id)),
+        );
+    }
+}
+
 fn inject_prelude(
     crate_id: CrateId,
     context: &Context,

compiler/noirc_frontend/src/hir/resolution/resolver.rs

@@ -1417,7 +1417,7 @@ impl<'a> Resolver<'a> {
                     // Otherwise, then it is referring to an Identifier
                     // This lookup allows support of such statements: let x = foo::bar::SOME_GLOBAL + 10;
                     // If the expression is a singular indent, we search the resolver's current scope as normal.
-                    let (hir_ident, var_scope_index) = self.get_ident_from_path(path);
+                    let (hir_ident, var_scope_index) = self.get_ident_from_path(path.clone());
 
                     if hir_ident.id != DefinitionId::dummy_id() {
                         match self.interner.definition(hir_ident.id).kind {
@@ -1436,6 +1436,13 @@ impl<'a> Resolver<'a> {
                                         self.interner.function_visibility(id),
                                     );
                                 }
+
+                                if let Some(func_meta) = self.interner.func_meta.get(&id) {
+                                    self.interner.add_reference(
+                                        (DependencyId::Function(id), func_meta.location),
+                                        (DependencyId::FunctionCall, hir_ident.location),
+                                    );
+                                }
                             }
                             DefinitionKind::Global(global_id) => {
                                 if let Some(current_item) = self.current_item {

compiler/noirc_frontend/src/lib.rs

@@ -14,6 +14,7 @@ pub mod ast;
 pub mod debug;
 pub mod graph;
 pub mod lexer;
+pub mod locations;
 pub mod monomorphization;
 pub mod node_interner;
 pub mod parser;

compiler/noirc_frontend/src/locations.rs

@@ -0,0 +1,108 @@
+use fm::FileId;
+use noirc_errors::Location;
+use rangemap::RangeMap;
+use rustc_hash::FxHashMap;
+
+use crate::{macros_api::NodeInterner, node_interner::DependencyId};
+use petgraph::prelude::NodeIndex as PetGraphIndex;
+
+#[derive(Debug, Default)]
+pub(crate) struct LocationStore {
+    map_file_to_range: FxHashMap<FileId, RangeMap<u32, PetGraphIndex>>,
+}
+
+impl LocationStore {
+    pub(crate) fn add_location(&mut self, location: Location, node_index: PetGraphIndex) {
+        let range_map = self.map_file_to_range.entry(location.file).or_insert_with(RangeMap::new);
+        range_map.insert(location.span.start()..location.span.end(), node_index);
+    }
+
+    pub(crate) fn get_node_from_location(&self, location: Location) -> Option<PetGraphIndex> {
+        let range_map = self.map_file_to_range.get(&location.file)?;
+        Some(*range_map.get(&location.span.start())?)
+    }
+}
+
+impl NodeInterner {
+    pub(crate) fn add_reference(
+        &mut self,
+        referenced: (DependencyId, Location),
+        reference: (DependencyId, Location),
+    ) {
+        let referenced_index = self.get_or_insert_reference(referenced);
+        let reference_index = self.graph_references.add_node((reference.0, reference.1));
+        self.graph_references.add_edge(referenced_index, reference_index, ());
+        self.location_store.add_location(referenced.1, referenced_index);
+        self.location_store.add_location(reference.1, reference_index);
+    }
+
+    pub(crate) fn add_reference_for(
+        &mut self,
+        referenced_id: DependencyId,
+        reference: (DependencyId, Location),
+    ) {
+        let Some(referenced_index) = self.graph_references_indices.get(&referenced_id) else { panic!("Compiler Error: Referenced index not found") };
+
+        let reference_index = self.graph_references.add_node((reference.0, reference.1));
+        self.graph_references.add_edge(*referenced_index, reference_index, ());
+        self.location_store.add_location(reference.1, reference_index);
+    }
+
+    pub(crate) fn add_definition(&mut self, referenced: (DependencyId, Location)) {
+        let referenced_index = self.get_or_insert_reference(referenced);
+        self.location_store.add_location(referenced.1, referenced_index);
+    }
+
+    #[tracing::instrument(skip(self), ret)]
+    pub(crate) fn get_or_insert_reference(
+        &mut self,
+        (id, location): (DependencyId, Location),
+    ) -> PetGraphIndex {
+        if let Some(index) = self.graph_references_indices.get(&id) {
+            return *index;
+        }
+
+        let index = self.graph_references.add_node((id, location));
+        self.graph_references_indices.insert(id, index);
+        index
+    }
+
+    pub fn check_rename_possible(&self, location: Location) -> bool {
+        self.location_store.get_node_from_location(location).is_some()
+    }
+
+    pub fn find_rename_symbols_at(&self, location: Location) -> Option<Vec<Location>> {
+        let node_index = self.location_store.get_node_from_location(location)?;
+
+        let reference_node = self.graph_references[node_index];
+        let found_locations: Vec<Location> = match reference_node.0 {
+            DependencyId::Alias(_) | DependencyId::Struct(_) | DependencyId::Global(_) => todo!(),
+            DependencyId::Function(_) => self.get_edit_locations(node_index),
+
+            DependencyId::FunctionCall => {
+                let referenced_node_index = self
+                    .graph_references
+                    .neighbors_directed(node_index, petgraph::Direction::Incoming)
+                    .next()?;
+
+                self.get_edit_locations(referenced_node_index)
+            }
+        };
+        Some(found_locations)
+    }
+
+    fn get_edit_locations(&self, referenced_node_index: PetGraphIndex) -> Vec<Location> {
+        let mut edit_locations: Vec<Location> = Vec::new();
+        let (_referenced_id, referencing_location) = self.graph_references[referenced_node_index];
+        edit_locations.push(referencing_location);
+
+        self.graph_references
+            .neighbors_directed(referenced_node_index, petgraph::Direction::Outgoing)
+            .for_each(|reference_node_index| {
+                let (_reference_dependency_id, reference_location) =
+                    self.graph_references[reference_node_index];
+                edit_locations.push(reference_location);
+            });
+        edit_locations
+    }
+}

compiler/noirc_frontend/src/node_interner.rs

@@ -26,6 +26,7 @@ use crate::hir_def::{
     function::{FuncMeta, HirFunction},
     stmt::HirStatement,
 };
+use crate::locations::LocationStore;
 use crate::token::{Attributes, SecondaryAttribute};
 use crate::{
     BinaryOpKind, ContractFunctionType, FunctionDefinition, FunctionVisibility, Generics, Shared,
@@ -60,7 +61,7 @@ pub struct NodeInterner {
     function_modules: HashMap<FuncId, ModuleId>,
 
     /// This graph tracks dependencies between different global definitions.
-    /// This is used to ensure the absense of dependency cycles for globals and types.
+    /// This is used to ensure the absence of dependency cycles for globals and types.
     dependency_graph: DiGraph<DependencyId, ()>,
 
     /// To keep track of where each DependencyId is in `dependency_graph`, we need
@@ -167,6 +168,13 @@ pub struct NodeInterner {
 
     /// Stores the [Location] of a [Type] reference
     pub(crate) type_ref_locations: Vec<(Type, Location)>,
+
+    /// Store the location of the references in the graph
+    pub(crate) graph_references: DiGraph<(DependencyId, Location), ()>,
+    /// Tracks the index of the references in the graph
+    pub(crate) graph_references_indices: HashMap<DependencyId, PetGraphIndex>,
+    /// Store the location of the references in the graph
+    pub(crate) location_store: LocationStore,
 }
 
 /// A dependency in the dependency graph may be a type or a definition.
@@ -185,6 +193,7 @@ pub enum DependencyId {
     Global(GlobalId),
     Function(FuncId),
     Alias(TypeAliasId),
+    FunctionCall,
 }
 
 /// A trait implementation is either a normal implementation that is present in the source
@@ -512,6 +521,9 @@ impl Default for NodeInterner {
             primitive_methods: HashMap::new(),
             type_alias_ref: Vec::new(),
             type_ref_locations: Vec::new(),
+            location_store: LocationStore::default(),
+            graph_references: petgraph::graph::DiGraph::new(),
+            graph_references_indices: HashMap::new(),
         };
 
         // An empty block expression is used often, we add this into the `node` on startup
@@ -788,6 +800,10 @@ impl NodeInterner {
             contract_function_type: Some(if function.is_open { Open } else { Secret }),
             is_internal: Some(function.is_internal),
         };
+        self.add_definition((
+            DependencyId::Function(id),
+            Location::new(function.name.span(), location.file),
+        ));
         self.push_function_definition(id, modifiers, module, location)
     }
 
@@ -1539,13 +1555,13 @@ impl NodeInterner {
         self.add_dependency(dependent, DependencyId::Function(dependency));
     }
 
-    fn add_dependency(&mut self, dependent: DependencyId, dependency: DependencyId) {
+    pub(crate) fn add_dependency(&mut self, dependent: DependencyId, dependency: DependencyId) {
         let dependent_index = self.get_or_insert_dependency(dependent);
         let dependency_index = self.get_or_insert_dependency(dependency);
         self.dependency_graph.update_edge(dependent_index, dependency_index, ());
     }
 
-    fn get_or_insert_dependency(&mut self, id: DependencyId) -> PetGraphIndex {
+    pub(crate) fn get_or_insert_dependency(&mut self, id: DependencyId) -> PetGraphIndex {
         if let Some(index) = self.dependency_graph_indices.get(&id) {
             return *index;
         }
@@ -1590,6 +1606,7 @@ impl NodeInterner {
                         }
                         // Mutually recursive functions are allowed
                         DependencyId::Function(_) => (),
+                        _ => (),
                     }
                 }
             }
@@ -1611,6 +1628,7 @@ impl NodeInterner {
             DependencyId::Global(id) => {
                 Cow::Borrowed(self.get_global(id).ident.0.contents.as_ref())
             }
+            _ => Cow::Borrowed(""),
         };
 
         let mut cycle = index_to_string(scc[start_index]).to_string();

cspell.json

@@ -87,6 +87,7 @@
         "indexmap",
         "injective",
         "Inlines",
+        "Instrumenter",
         "interner",
         "intrinsics",
         "jmp",
@@ -102,6 +103,7 @@
         "lvalue",
         "Maddiaa",
         "mathbb",
+        "memfs",
         "merkle",
         "metas",
         "minreq",
@@ -127,6 +129,7 @@
         "nouner",
         "pedersen",
         "peekable",
+        "petgraph",
         "plonkc",
         "PLONKish",
         "pprof",
@@ -136,6 +139,7 @@
         "pseudocode",
         "pubkey",
         "quantile",
+        "rangemap",
         "repr",
         "reqwest",
         "rfind",
@@ -157,6 +161,7 @@
         "subtyping",
         "swcurve",
         "Taiko",
+        "tarjan",
         "tecurve",
         "tempdir",
         "tempfile",
@@ -174,6 +179,7 @@
         "urem",
         "USERPROFILE",
         "vecmap",
+        "vitkov",
         "wasi",
         "wasmer",
         "Weierstraß",