feat: nargo expand to show code after macro expansions

compiler/noirc_frontend/src/elaborator/enums.rs

@@ -955,11 +955,18 @@ impl<'elab, 'ctx> MatchCompiler<'elab, 'ctx> {
         variable_types: Vec<Type>,
         location: Location,
     ) -> Vec<DefinitionId> {
-        vecmap(variable_types, |typ| self.fresh_match_variable(typ, location))
+        vecmap(variable_types.into_iter().enumerate(), |(index, typ)| {
+            self.fresh_match_variable(index, typ, location)
+        })
     }
 
-    fn fresh_match_variable(&mut self, variable_type: Type, location: Location) -> DefinitionId {
-        let name = "internal_match_variable".to_string();
+    fn fresh_match_variable(
+        &mut self,
+        index: usize,
+        variable_type: Type,
+        location: Location,
+    ) -> DefinitionId {
+        let name = format!("internal_match_variable_{index}");
         let kind = DefinitionKind::Local(None);
         let id = self.elaborator.interner.push_definition(name, false, false, kind, location);
         self.elaborator.interner.push_definition_type(id, variable_type);

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -1573,10 +1573,12 @@ impl<'context> Elaborator<'context> {
 
             let resolved_trait_impl = Shared::new(TraitImpl {
                 ident,
+                location,
                 typ: self_type.clone(),
                 trait_id,
                 trait_generics,
                 file: trait_impl.file_id,
+                crate_id: self.crate_id,
                 where_clause,
                 methods,
             });

compiler/noirc_frontend/src/elaborator/statements.rs

@@ -402,8 +402,12 @@ impl Elaborator<'_> {
                     let tmp_value = HirLValue::Ident(ident, Type::Error);
 
                     let lvalue = std::mem::replace(object_ref, Box::new(tmp_value));
-                    *object_ref =
-                        Box::new(HirLValue::Dereference { lvalue, element_type, location });
+                    *object_ref = Box::new(HirLValue::Dereference {
+                        lvalue,
+                        element_type,
+                        location,
+                        implicitly_added: true,
+                    });
                     *mutable_ref = true;
                 };
 
@@ -442,8 +446,12 @@ impl Elaborator<'_> {
                 // as needed to unwrap any `&` or `&mut` wrappers.
                 while let Type::Reference(element, _) = lvalue_type.follow_bindings() {
                     let element_type = element.as_ref().clone();
-                    lvalue =
-                        HirLValue::Dereference { lvalue: Box::new(lvalue), element_type, location };
+                    lvalue = HirLValue::Dereference {
+                        lvalue: Box::new(lvalue),
+                        element_type,
+                        location,
+                        implicitly_added: true,
+                    };
                     lvalue_type = *element;
                     // We know this value to be mutable now since we found an `&mut`
                     mutable = true;
@@ -496,7 +504,12 @@ impl Elaborator<'_> {
 
                 // Dereferences are always mutable since we already type checked against a &mut T
                 let typ = element_type.clone();
-                let lvalue = HirLValue::Dereference { lvalue, element_type, location };
+                let lvalue = HirLValue::Dereference {
+                    lvalue,
+                    element_type,
+                    location,
+                    implicitly_added: false,
+                };
                 (lvalue, typ, true)
             }
             LValue::Interned(id, location) => {

compiler/noirc_frontend/src/hir/comptime/display.rs

@@ -63,8 +63,16 @@ impl Display for TokensPrettyPrinter<'_, '_> {
     }
 }
 
-pub(super) fn tokens_to_string(tokens: &[LocatedToken], interner: &NodeInterner) -> String {
-    TokensPrettyPrinter { tokens, interner, indent: 0 }.to_string()
+pub fn tokens_to_string(tokens: &[LocatedToken], interner: &NodeInterner) -> String {
+    tokens_to_string_with_indent(tokens, 0, interner)
+}
+
+pub fn tokens_to_string_with_indent(
+    tokens: &[LocatedToken],
+    indent: usize,
+    interner: &NodeInterner,
+) -> String {
+    TokensPrettyPrinter { tokens, interner, indent }.to_string()
 }
 
 /// Tries to print tokens in a way that it'll be easier for the user to understand a

compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs

@@ -504,7 +504,7 @@ impl HirLValue {
                 let index = index.to_display_ast(interner);
                 LValue::Index { array, index, location: *location }
             }
-            HirLValue::Dereference { lvalue, element_type: _, location } => {
+            HirLValue::Dereference { lvalue, element_type: _, location, implicitly_added: _ } => {
                 let lvalue = Box::new(lvalue.to_display_ast(interner));
                 LValue::Dereference(lvalue, *location)
             }

compiler/noirc_frontend/src/hir/comptime/interpreter.rs

@@ -257,7 +257,7 @@
             }
         } else {
             let name = self.elaborator.interner.function_name(&function);
             unreachable!("Non-builtin, lowlevel or oracle builtin fn '{name}'")
         }
     }
 
@@ -1111,7 +1111,7 @@
     fn store_lvalue(&mut self, lvalue: HirLValue, rhs: Value) -> IResult<()> {
         match lvalue {
             HirLValue::Ident(ident, typ) => self.mutate(ident.id, rhs, ident.location),
-            HirLValue::Dereference { lvalue, element_type: _, location } => {
+            HirLValue::Dereference { lvalue, element_type: _, location, implicitly_added: _ } => {
                 match self.evaluate_lvalue(&lvalue)? {
                     Value::Pointer(value, _, _) => {
                         *value.borrow_mut() = rhs;
@@ -1172,7 +1172,7 @@
                 Value::Pointer(elem, true, _) => Ok(elem.borrow().clone()),
                 other => Ok(other),
             },
-            HirLValue::Dereference { lvalue, element_type, location } => {
+            HirLValue::Dereference { lvalue, element_type, location, implicitly_added: _ } => {
                 match self.evaluate_lvalue(lvalue)? {
                     Value::Pointer(value, _, _) => Ok(value.borrow().clone()),
                     value => {

compiler/noirc_frontend/src/hir/comptime/mod.rs

@@ -5,6 +5,7 @@ mod interpreter;
 mod tests;
 mod value;
 
+pub use display::{tokens_to_string, tokens_to_string_with_indent};
 pub use errors::{ComptimeError, InterpreterError};
 pub use interpreter::Interpreter;
 pub use value::Value;

compiler/noirc_frontend/src/hir_def/stmt.rs

@@ -150,6 +150,7 @@ pub enum HirLValue {
     Dereference {
         lvalue: Box<HirLValue>,
         element_type: Type,
+        implicitly_added: bool,
         location: Location,
     },
 }

compiler/noirc_frontend/src/hir_def/traits.rs

@@ -83,6 +83,7 @@ pub struct Trait {
 #[derive(Debug)]
 pub struct TraitImpl {
     pub ident: Ident,
+    pub location: Location,
     pub typ: Type,
     pub trait_id: TraitId,
 
@@ -95,6 +96,7 @@ pub struct TraitImpl {
     pub trait_generics: Vec<Type>,
 
     pub file: FileId,
+    pub crate_id: CrateId,
     pub methods: Vec<FuncId>, // methods[i] is the implementation of trait.methods[i] for Type typ
 
     /// The where clause, if present, contains each trait requirement which must

compiler/noirc_frontend/src/lib.rs

@@ -24,6 +24,7 @@ pub mod elaborator;
 pub mod graph;
 pub mod lexer;
 pub mod locations;
+pub mod modules;
 pub mod monomorphization;
 pub mod node_interner;
 pub mod ownership;

compiler/noirc_frontend/src/modules.rs

@@ -0,0 +1,211 @@
+use crate::{
+    ast::Ident,
+    graph::{CrateId, Dependency},
+    hir::def_map::{ModuleDefId, ModuleId},
+    node_interner::{NodeInterner, ReferenceId},
+};
+
+pub fn get_parent_module(interner: &NodeInterner, module_def_id: ModuleDefId) -> Option<ModuleId> {
+    let reference_id = module_def_id_to_reference_id(module_def_id);
+    interner.reference_module(reference_id).copied()
+}
+
+pub fn module_def_id_to_reference_id(module_def_id: ModuleDefId) -> ReferenceId {
+    match module_def_id {
+        ModuleDefId::ModuleId(id) => ReferenceId::Module(id),
+        ModuleDefId::FunctionId(id) => ReferenceId::Function(id),
+        ModuleDefId::TypeId(id) => ReferenceId::Type(id),
+        ModuleDefId::TypeAliasId(id) => ReferenceId::Alias(id),
+        ModuleDefId::TraitId(id) => ReferenceId::Trait(id),
+        ModuleDefId::GlobalId(id) => ReferenceId::Global(id),
+    }
+}
+
+/// Returns the fully-qualified path of the given `ModuleDefId` relative to `current_module_id`:
+/// - If `ModuleDefId` is a module, that module's path is returned
+/// - Otherwise, that item's parent module's path is returned
+pub fn relative_module_full_path(
+    module_def_id: ModuleDefId,
+    current_module_id: ModuleId,
+    current_module_parent_id: Option<ModuleId>,
+    interner: &NodeInterner,
+) -> Option<String> {
+    let full_path;
+    if let ModuleDefId::ModuleId(module_id) = module_def_id {
+        full_path = relative_module_id_path(
+            module_id,
+            current_module_id,
+            current_module_parent_id,
+            interner,
+        );
+    } else {
+        let parent_module = get_parent_module(interner, module_def_id)?;
+
+        // If module_def_id is contained in the current module, the relative path is empty
+        if current_module_id == parent_module {
+            return None;
+        }
+
+        full_path = relative_module_id_path(
+            parent_module,
+            current_module_id,
+            current_module_parent_id,
+            interner,
+        );
+    }
+    Some(full_path)
+}
+
+/// Returns the path to reach an item inside `target_module_id` from inside `current_module_id`.
+/// Returns a relative path if possible.
+pub fn relative_module_id_path(
+    target_module_id: ModuleId,
+    current_module_id: ModuleId,
+    current_module_parent_id: Option<ModuleId>,
+    interner: &NodeInterner,
+) -> String {
+    if Some(target_module_id) == current_module_parent_id {
+        return "super".to_string();
+    }
+
+    let mut segments: Vec<&str> = Vec::new();
+    let mut is_relative = false;
+
+    if let Some(module_attributes) = interner.try_module_attributes(&target_module_id) {
+        segments.push(&module_attributes.name);
+
+        let mut current_attributes = module_attributes;
+        loop {
+            let Some(parent_local_id) = current_attributes.parent else {
+                break;
+            };
+
+            let parent_module_id =
+                &ModuleId { krate: target_module_id.krate, local_id: parent_local_id };
+
+            if current_module_id == *parent_module_id {
+                is_relative = true;
+                break;
+            }
+
+            if current_module_parent_id == Some(*parent_module_id) {
+                segments.push("super");
+                is_relative = true;
+                break;
+            }
+
+            let Some(parent_attributes) = interner.try_module_attributes(parent_module_id) else {
+                break;
+            };
+
+            segments.push(&parent_attributes.name);
+            current_attributes = parent_attributes;
+        }
+    }
+
+    if !is_relative {
+        // We don't record module attributes for the root module,
+        // so we handle that case separately
+        if target_module_id.krate.is_root() {
+            segments.push("crate");
+        }
+    }
+
+    segments.reverse();
+    segments.join("::")
+}
+
+pub fn module_full_path(
+    module: &ModuleId,
+    interner: &NodeInterner,
+    crate_id: CrateId,
+    crate_name: &str,
+    dependencies: &Vec<Dependency>,
+) -> String {
+    let mut segments: Vec<String> = Vec::new();
+
+    if let Some(module_attributes) = interner.try_module_attributes(module) {
+        segments.push(module_attributes.name.clone());
+
+        let mut current_attributes = module_attributes;
+        loop {
+            let Some(parent_local_id) = current_attributes.parent else {
+                break;
+            };
+
+            let Some(parent_attributes) = interner.try_module_attributes(&ModuleId {
+                krate: module.krate,
+                local_id: parent_local_id,
+            }) else {
+                break;
+            };
+
+            segments.push(parent_attributes.name.clone());
+            current_attributes = parent_attributes;
+        }
+    }
+
+    // We don't record module attributes for the root module,
+    // so we handle that case separately
+    if module.krate.is_root() {
+        if module.krate == crate_id {
+            segments.push(crate_name.to_string());
+        } else {
+            for dep in dependencies {
+                if dep.crate_id == crate_id {
+                    segments.push(dep.name.to_string());
+                    break;
+                }
+            }
+        }
+    };
+
+    segments.reverse();
+    segments.join("::")
+}
+
+/// Returns the relative path to reach `module_def_id` named `name` starting from `current_module_id`.
+///
+/// - `defining_module` might be `Some` if the item is reexported from another module
+/// - `intermediate_name` might be `Some` if the item's parent module is reexport from another module
+///   (this will be the name of the reexport)
+///
+/// Returns `None` if `module_def_id` isn't visible from the current module, neither directly, neither via
+/// any of its reexports (or parent module reexports).
+pub fn module_def_id_relative_path(
+    module_def_id: ModuleDefId,
+    name: &str,
+    current_module_id: ModuleId,
+    current_module_parent_id: Option<ModuleId>,
+    defining_module: Option<ModuleId>,
+    intermediate_name: &Option<Ident>,
+    interner: &NodeInterner,
+) -> Option<String> {
+    let module_path = if let Some(defining_module) = defining_module {
+        relative_module_id_path(
+            defining_module,
+            current_module_id,
+            current_module_parent_id,
+            interner,
+        )
+    } else {
+        relative_module_full_path(
+            module_def_id,
+            current_module_id,
+            current_module_parent_id,
+            interner,
+        )?
+    };
+
+    let path = if defining_module.is_some() || !matches!(module_def_id, ModuleDefId::ModuleId(..)) {
+        if let Some(reexport_name) = &intermediate_name {
+            format!("{}::{}::{}", module_path, reexport_name, name)
+        } else {
+            format!("{}::{}", module_path, name)
+        }
+    } else {
+        module_path.clone()
+    };
+
+    Some(path)
+}

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -1921,7 +1921,7 @@ impl<'interner> Monomorphizer<'interner> {
                 let element_type = Self::convert_type(&typ, location)?;
                 ast::LValue::Index { array, index, element_type, location }
             }
-            HirLValue::Dereference { lvalue, element_type, location } => {
+            HirLValue::Dereference { lvalue, element_type, location, implicitly_added: _ } => {
                 let reference = Box::new(self.lvalue(*lvalue)?);
                 let element_type = Self::convert_type(&element_type, location)?;
                 ast::LValue::Dereference { reference, element_type }