feat: lsp rename/find-all-references for globals

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -1350,6 +1350,8 @@ impl<'context> Elaborator<'context> {
             self.elaborate_comptime_global(global_id);
         }
 
+        self.interner.add_definition_location(ReferenceId::Global(global_id));
+
         self.local_module = old_module;
         self.file = old_file;
         self.current_item = old_item;

compiler/noirc_frontend/src/elaborator/types.rs

@@ -154,9 +154,6 @@ impl<'context> Elaborator<'context> {
         };
 
         if let Some(unresolved_span) = typ.span {
-            let reference =
-                ReferenceId::Variable(Location::new(unresolved_span, self.file), is_self_type_name);
-
             match resolved_type {
                 Type::Struct(ref struct_type, _) => {
                     // Record the location of the type reference
@@ -167,11 +164,19 @@ impl<'context> Elaborator<'context> {
 
                     if !is_synthetic {
                         let referenced = ReferenceId::Struct(struct_type.borrow().id);
+                        let reference = ReferenceId::Variable(
+                            Location::new(unresolved_span, self.file),
+                            is_self_type_name,
+                        );
                         self.interner.add_reference(referenced, reference);
                     }
                 }
                 Type::Alias(ref alias_type, _) => {
                     let referenced = ReferenceId::Alias(alias_type.borrow().id);
+                    let reference = ReferenceId::Variable(
+                        Location::new(unresolved_span, self.file),
+                        is_self_type_name,
+                    );
                     self.interner.add_reference(referenced, reference);
                 }
                 _ => (),
@@ -364,6 +369,10 @@ impl<'context> Elaborator<'context> {
                     self.interner.add_global_dependency(current_item, id);
                 }
 
+                let referenced = ReferenceId::Global(id);
+                let reference = ReferenceId::Variable(Location::new(path.span(), self.file), false);
+                self.interner.add_reference(referenced, reference);
+
                 Some(Type::Constant(self.eval_global_as_array_length(id, path)))
             }
             _ => None,

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

@@ -511,25 +511,18 @@ fn add_import_reference(
         return;
     }
 
-    match def_id {
-        crate::macros_api::ModuleDefId::FunctionId(func_id) => {
-            let variable = ReferenceId::Variable(Location::new(name.span(), file_id), false);
-            interner.add_reference(ReferenceId::Function(func_id), variable);
-        }
-        crate::macros_api::ModuleDefId::TypeId(struct_id) => {
-            let variable = ReferenceId::Variable(Location::new(name.span(), file_id), false);
-            interner.add_reference(ReferenceId::Struct(struct_id), variable);
-        }
-        crate::macros_api::ModuleDefId::TraitId(trait_id) => {
-            let variable = ReferenceId::Variable(Location::new(name.span(), file_id), false);
-            interner.add_reference(ReferenceId::Trait(trait_id), variable);
-        }
+    let referenced = match def_id {
+        crate::macros_api::ModuleDefId::ModuleId(module_id) => ReferenceId::Module(module_id),
+        crate::macros_api::ModuleDefId::FunctionId(func_id) => ReferenceId::Function(func_id),
+        crate::macros_api::ModuleDefId::TypeId(struct_id) => ReferenceId::Struct(struct_id),
+        crate::macros_api::ModuleDefId::TraitId(trait_id) => ReferenceId::Trait(trait_id),
         crate::macros_api::ModuleDefId::TypeAliasId(type_alias_id) => {
-            let variable = ReferenceId::Variable(Location::new(name.span(), file_id), false);
-            interner.add_reference(ReferenceId::Alias(type_alias_id), variable);
+            ReferenceId::Alias(type_alias_id)
         }
-        _ => (),
-    }
+        crate::macros_api::ModuleDefId::GlobalId(global_id) => ReferenceId::Global(global_id),
+    };
+    let reference = ReferenceId::Variable(Location::new(name.span(), file_id), false);
+    interner.add_reference(referenced, reference);
 }
 
 fn inject_prelude(

compiler/noirc_frontend/src/locations.rs

@@ -117,26 +117,18 @@ impl NodeInterner {
         let node_index = self.location_indices.get_node_from_location(location)?;
 
         let reference_node = self.reference_graph[node_index];
-        let found_locations: Vec<Location> = match reference_node {
-            ReferenceId::Global(_) | ReferenceId::Module(_) => todo!(),
-            ReferenceId::Function(_)
-            | ReferenceId::Struct(_)
-            | ReferenceId::Trait(_)
-            | ReferenceId::Alias(_) => self.find_all_references_for_index(
-                node_index,
-                include_referenced,
-                include_self_type_name,
-            ),
-
-            ReferenceId::Variable(_, _) => {
-                let referenced_node_index = self.referenced_index(node_index)?;
-                self.find_all_references_for_index(
-                    referenced_node_index,
-                    include_referenced,
-                    include_self_type_name,
-                )
-            }
+        let referenced_node_index = if let ReferenceId::Variable(_, _) = reference_node {
+            self.referenced_index(node_index)?
+        } else {
+            node_index
         };
+
+        let found_locations = self.find_all_references_for_index(
+            referenced_node_index,
+            include_referenced,
+            include_self_type_name,
+        );
+
         Some(found_locations)
     }
 

tooling/lsp/src/requests/rename.rs

@@ -189,4 +189,9 @@ mod rename_tests {
     async fn test_rename_type_alias() {
         check_rename_succeeds("rename_type_alias", "Bar").await;
     }
+
+    #[test]
+    async fn test_rename_global() {
+        check_rename_succeeds("rename_global", "FOO").await;
+    }
 }

tooling/lsp/test_programs/rename_global/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "rename_global"
+type = "bin"
+authors = [""]
+
+[dependencies]

tooling/lsp/test_programs/rename_global/src/main.nr

@@ -0,0 +1,22 @@
+mod foo {
+    global FOO = 1;
+}
+
+use foo::FOO;
+
+fn main() {
+    let _ = foo::FOO;
+    let _ = FOO;
+    let _: [Field; FOO] = [1];
+}
+
+trait WithNumber<N> {
+
+}
+
+struct Some {
+}
+
+impl WithNumber<FOO> for Some {
+
+}

tooling/lsp/test_programs/rename_type_alias/src/main.nr

@@ -3,10 +3,17 @@ mod foo {
     }
 
     type Bar = Foo;
+
+    mod bar {
+        struct Baz {
+
+        }
+    }
 }
 
 use foo::Foo;
 use foo::Bar;
+use foo::bar;
 
 fn main() {
     let x: Bar = Foo {};