[1 changes] feat: lsp rename/find-all-references for traits (noir-lang/noir#5409)

feat: lsp "go to definition" for modules (noir-lang/noir#5406)
fix: lsp find struct reference in return locations and paths (noir-lang/noir#5404)
feat: Sync from aztec-packages (noir-lang/noir#5408)

Author: AztecBot

.noir-sync-commit

@@ -1 +1 @@
-70ebf607e566a95ff7eb2c7a0eee7c36465ba5b4
+bf3a75a3f9c6926baaa1408767dd929de2f8a8f9

noir/noir-repo/acvm-repo/acvm_js/build.sh

@@ -25,7 +25,7 @@ function run_if_available {
 require_command jq
 require_command cargo
 require_command wasm-bindgen
-#require_command wasm-opt
+require_command wasm-opt
 
 self_path=$(dirname "$(readlink -f "$0")")
 pname=$(cargo read-manifest | jq -r '.name')

noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs

@@ -27,7 +27,7 @@ use crate::{
         HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
         MethodCallExpression, PrefixExpression,
     },
-    node_interner::{DefinitionKind, DependencyId, ExprId, FuncId},
+    node_interner::{DefinitionKind, ExprId, FuncId, ReferenceId},
     token::Tokens,
     Kind, QuotedType, Shared, StructType, Type,
 };
@@ -432,8 +432,8 @@ impl<'context> Elaborator<'context> {
             struct_generics,
         });
 
-        let referenced = DependencyId::Struct(struct_type.borrow().id);
-        let reference = DependencyId::Variable(Location::new(span, self.file));
+        let referenced = ReferenceId::Struct(struct_type.borrow().id);
+        let reference = ReferenceId::Variable(Location::new(span, self.file));
         self.interner.add_reference(referenced, reference);
 
         (expr, Type::Struct(struct_type, generics))

noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs

@@ -30,7 +30,8 @@ use crate::{
         SecondaryAttribute, StructId,
     },
     node_interner::{
-        DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, TraitId, TypeAliasId,
+        DefinitionId, DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, ReferenceId, TraitId,
+        TypeAliasId,
     },
     parser::TopLevelStatement,
     Shared, Type, TypeBindings, TypeVariable,
@@ -534,7 +535,7 @@ impl<'context> Elaborator<'context> {
     fn resolve_trait_by_path(&mut self, path: Path) -> Option<TraitId> {
         let path_resolver = StandardPathResolver::new(self.module_id());
 
-        let error = match path_resolver.resolve(self.def_maps, path.clone()) {
+        let error = match path_resolver.resolve(self.def_maps, path.clone(), &mut None) {
             Ok(PathResolution { module_def_id: ModuleDefId::TraitId(trait_id), error }) => {
                 if let Some(error) = error {
                     self.push_err(error);
@@ -1407,7 +1408,8 @@ impl<'context> Elaborator<'context> {
             self.file = trait_impl.file_id;
             self.local_module = trait_impl.module_id;
 
-            trait_impl.trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
+            let trait_id = self.resolve_trait_by_path(trait_impl.trait_path.clone());
+            trait_impl.trait_id = trait_id;
             let unresolved_type = &trait_impl.object_type;
 
             self.add_generics(&trait_impl.generics);
@@ -1445,6 +1447,15 @@ impl<'context> Elaborator<'context> {
             trait_impl.resolved_object_type = self.self_type.take();
             trait_impl.impl_id = self.current_trait_impl.take();
             self.generics.clear();
+
+            if let Some(trait_id) = trait_id {
+                let referenced = ReferenceId::Trait(trait_id);
+                let reference = ReferenceId::Variable(Location::new(
+                    trait_impl.trait_path.last_segment().span(),
+                    trait_impl.file_id,
+                ));
+                self.interner.add_reference(referenced, reference);
+            }
         }
     }
 

noir/noir-repo/compiler/noirc_frontend/src/elaborator/patterns.rs

@@ -15,7 +15,7 @@ use crate::{
         stmt::HirPattern,
     },
     macros_api::{HirExpression, Ident, Path, Pattern},
-    node_interner::{DefinitionId, DefinitionKind, DependencyId, ExprId, GlobalId, TraitImplKind},
+    node_interner::{DefinitionId, DefinitionKind, ExprId, GlobalId, ReferenceId, TraitImplKind},
     Shared, StructType, Type, TypeBindings,
 };
 
@@ -199,8 +199,8 @@ impl<'context> Elaborator<'context> {
             new_definitions,
         );
 
-        let referenced = DependencyId::Struct(struct_type.borrow().id);
-        let reference = DependencyId::Variable(Location::new(name_span, self.file));
+        let referenced = ReferenceId::Struct(struct_type.borrow().id);
+        let reference = ReferenceId::Variable(Location::new(name_span, self.file));
         self.interner.add_reference(referenced, reference);
 
         HirPattern::Struct(expected_type, fields, location)
@@ -446,8 +446,8 @@ impl<'context> Elaborator<'context> {
                             self.interner.add_function_dependency(current_item, func_id);
                         }
 
-                        let variable = DependencyId::Variable(hir_ident.location);
-                        let function = DependencyId::Function(func_id);
+                        let variable = ReferenceId::Variable(hir_ident.location);
+                        let function = ReferenceId::Function(func_id);
                         self.interner.add_reference(function, variable);
                     }
                     DefinitionKind::Global(global_id) => {
@@ -458,8 +458,8 @@ impl<'context> Elaborator<'context> {
                             self.interner.add_global_dependency(current_item, global_id);
                         }
 
-                        let variable = DependencyId::Variable(hir_ident.location);
-                        let global = DependencyId::Global(global_id);
+                        let variable = ReferenceId::Variable(hir_ident.location);
+                        let global = ReferenceId::Global(global_id);
                         self.interner.add_reference(global, variable);
                     }
                     DefinitionKind::GenericType(_) => {

noir/noir-repo/compiler/noirc_frontend/src/elaborator/scope.rs

@@ -1,11 +1,12 @@
-use noirc_errors::Spanned;
+use noirc_errors::{Location, Spanned};
 
 use crate::ast::ERROR_IDENT;
 use crate::hir::def_map::{LocalModuleId, ModuleId};
 use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
 use crate::hir::resolution::resolver::SELF_TYPE_NAME;
 use crate::hir::scope::{Scope as GenericScope, ScopeTree as GenericScopeTree};
 use crate::macros_api::Ident;
+use crate::node_interner::ReferenceId;
 use crate::{
     hir::{
         def_map::{ModuleDefId, TryFromModuleDefId},
@@ -44,7 +45,20 @@ impl<'context> Elaborator<'context> {
 
     pub(super) fn resolve_path(&mut self, path: Path) -> Result<ModuleDefId, ResolverError> {
         let resolver = StandardPathResolver::new(self.module_id());
-        let path_resolution = resolver.resolve(self.def_maps, path)?;
+        let path_resolution;
+
+        if self.interner.track_references {
+            let mut references: Vec<ReferenceId> = Vec::new();
+            path_resolution =
+                resolver.resolve(self.def_maps, path.clone(), &mut Some(&mut references))?;
+
+            for (referenced, ident) in references.iter().zip(path.segments) {
+                let reference = ReferenceId::Variable(Location::new(ident.span(), self.file));
+                self.interner.add_reference(*referenced, reference);
+            }
+        } else {
+            path_resolution = resolver.resolve(self.def_maps, path, &mut None)?;
+        }
 
         if let Some(error) = path_resolution.error {
             self.push_err(error);

noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs

@@ -31,7 +31,8 @@ use crate::{
         UnaryOp, UnresolvedType, UnresolvedTypeData,
     },
     node_interner::{
-        DefinitionKind, DependencyId, ExprId, GlobalId, TraitId, TraitImplKind, TraitMethodId,
+        DefinitionKind, DependencyId, ExprId, GlobalId, ReferenceId, TraitId, TraitImplKind,
+        TraitMethodId,
     },
     Generics, Kind, ResolvedGeneric, Type, TypeBinding, TypeVariable, TypeVariableKind,
 };
@@ -146,13 +147,17 @@ impl<'context> Elaborator<'context> {
             Resolved(id) => self.interner.get_quoted_type(id).clone(),
         };
 
-        if let Type::Struct(_, _) = resolved_type {
+        if let Type::Struct(ref struct_type, _) = resolved_type {
             if let Some(unresolved_span) = typ.span {
                 // Record the location of the type reference
                 self.interner.push_type_ref_location(
                     resolved_type.clone(),
                     Location::new(unresolved_span, self.file),
                 );
+
+                let referenced = ReferenceId::Struct(struct_type.borrow().id);
+                let reference = ReferenceId::Variable(Location::new(unresolved_span, self.file));
+                self.interner.add_reference(referenced, reference);
             }
         }
 
@@ -244,8 +249,6 @@ impl<'context> Elaborator<'context> {
             return Type::Alias(alias, args);
         }
 
-        let last_segment = path.last_segment();
-
         match self.lookup_struct_or_error(path) {
             Some(struct_type) => {
                 if self.resolving_ids.contains(&struct_type.borrow().id) {
@@ -283,11 +286,6 @@ impl<'context> Elaborator<'context> {
                     self.interner.add_type_dependency(current_item, dependency_id);
                 }
 
-                let referenced = DependencyId::Struct(struct_type.borrow().id);
-                let reference =
-                    DependencyId::Variable(Location::new(last_segment.span(), self.file));
-                self.interner.add_reference(referenced, reference);
-
                 Type::Struct(struct_type, args)
             }
             None => Type::Error,

noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs

@@ -20,7 +20,7 @@ use crate::hir::Context;
 
 use crate::macros_api::{MacroError, MacroProcessor};
 use crate::node_interner::{
-    DependencyId, FuncId, GlobalId, NodeInterner, StructId, TraitId, TraitImplId, TypeAliasId,
+    FuncId, GlobalId, NodeInterner, ReferenceId, StructId, TraitId, TraitImplId, TypeAliasId,
 };
 
 use crate::ast::{
@@ -330,7 +330,28 @@ impl DefCollector {
         // Resolve unresolved imports collected from the crate, one by one.
         for collected_import in std::mem::take(&mut def_collector.imports) {
             let module_id = collected_import.module_id;
-            match resolve_import(crate_id, &collected_import, &context.def_maps) {
+            let resolved_import = if context.def_interner.track_references {
+                let mut references: Vec<ReferenceId> = Vec::new();
+                let resolved_import = resolve_import(
+                    crate_id,
+                    &collected_import,
+                    &context.def_maps,
+                    &mut Some(&mut references),
+                );
+
+                let current_def_map = context.def_maps.get(&crate_id).unwrap();
+                let file_id = current_def_map.file_id(module_id);
+
+                for (referenced, ident) in references.iter().zip(&collected_import.path.segments) {
+                    let reference = ReferenceId::Variable(Location::new(ident.span(), file_id));
+                    context.def_interner.add_reference(*referenced, reference);
+                }
+
+                resolved_import
+            } else {
+                resolve_import(crate_id, &collected_import, &context.def_maps, &mut None)
+            };
+            match resolved_import {
                 Ok(resolved_import) => {
                     if let Some(error) = resolved_import.error {
                         errors.push((
@@ -491,12 +512,16 @@ fn add_import_reference(
 
     match def_id {
         crate::macros_api::ModuleDefId::FunctionId(func_id) => {
-            let variable = DependencyId::Variable(Location::new(name.span(), file_id));
-            interner.add_reference(DependencyId::Function(func_id), variable);
+            let variable = ReferenceId::Variable(Location::new(name.span(), file_id));
+            interner.add_reference(ReferenceId::Function(func_id), variable);
         }
         crate::macros_api::ModuleDefId::TypeId(struct_id) => {
-            let variable = DependencyId::Variable(Location::new(name.span(), file_id));
-            interner.add_reference(DependencyId::Struct(struct_id), variable);
+            let variable = ReferenceId::Variable(Location::new(name.span(), file_id));
+            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));
+            interner.add_reference(ReferenceId::Trait(trait_id), variable);
         }
         _ => (),
     }
@@ -524,6 +549,7 @@ fn inject_prelude(
             &context.def_maps,
             ModuleId { krate: crate_id, local_id: crate_root },
             path,
+            &mut None,
         ) {
             assert!(error.is_none(), "Tried to add private item to prelude");
             let module_id = module_def_id.as_module().expect("std::prelude should be a module");