feat: nargo expand to show code after macro expansions

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -1511,10 +1511,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/hir/comptime/display.rs

@@ -63,7 +63,7 @@ impl Display for TokensPrettyPrinter<'_, '_> {
     }
 }
 
-pub(super) fn tokens_to_string(tokens: &[LocatedToken], interner: &NodeInterner) -> String {
+pub fn tokens_to_string(tokens: &[LocatedToken], interner: &NodeInterner) -> String {
     TokensPrettyPrinter { tokens, interner, indent: 0 }.to_string()
 }
 

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

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

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/node_interner.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashSet;
 use std::fmt;
 use std::hash::Hash;
 use std::marker::Copy;
@@ -216,12 +217,12 @@
     interned_statement_kinds: noirc_arena::Arena<StatementKind>,
 
     // Interned `UnresolvedTypeData`s during comptime code.
     interned_unresolved_type_datas: noirc_arena::Arena<UnresolvedTypeData>,
 
     // Interned `Pattern`s during comptime code.
     interned_patterns: noirc_arena::Arena<Pattern>,
 
     /// Determins whether to run in LSP mode. In LSP mode references are tracked.
     pub(crate) lsp_mode: bool,
 
     /// Store the location of the references in the graph.
@@ -697,7 +698,7 @@
             quoted_types: Default::default(),
             interned_expression_kinds: Default::default(),
             interned_statement_kinds: Default::default(),
             interned_unresolved_type_datas: Default::default(),
             interned_patterns: Default::default(),
             lsp_mode: false,
             location_indices: LocationIndices::default(),
@@ -1450,6 +1451,14 @@
         self.trait_implementations[&id].clone()
     }
 
+    pub fn get_trait_implementations_in_crate(&self, crate_id: CrateId) -> HashSet<TraitImplId> {
+        let trait_impls = self.trait_implementations.iter();
+        let trait_impls = trait_impls.filter_map(|(id, trait_impl)| {
+            if trait_impl.borrow().crate_id == crate_id { Some(*id) } else { None }
+        });
+        trait_impls.collect()
+    }
+
     /// If the given function belongs to a trait impl, return its trait method id.
     /// Otherwise, return None.
     pub fn get_trait_method_id(&self, function: FuncId) -> Option<TraitMethodId> {
@@ -2184,11 +2193,11 @@
         &mut self,
         typ: UnresolvedTypeData,
     ) -> InternedUnresolvedTypeData {
         InternedUnresolvedTypeData(self.interned_unresolved_type_datas.insert(typ))
     }
 
     pub fn get_unresolved_type_data(&self, id: InternedUnresolvedTypeData) -> &UnresolvedTypeData {
         &self.interned_unresolved_type_datas[id.0]
     }
 
     /// Returns the type of an operator (which is always a function), along with its return type.

tooling/nargo_cli/Cargo.toml

@@ -67,6 +67,7 @@ color-eyre.workspace = true
 tokio = { version = "1.0", features = ["io-std", "rt"] }
 dap.workspace = true
 clap-markdown = { git = "https://github.com/noir-lang/clap-markdown", rev = "450d759532c88f0dba70891ceecdbc9ff8f25d2b", optional = true }
+rustc-hash = "1.1.0"
 
 notify = "6.1.1"
 notify-debouncer-full = "0.3.1"

tooling/nargo_cli/src/cli/expand_cmd.rs

@@ -0,0 +1,71 @@
+use clap::Args;
+use fm::FileManager;
+use nargo::{
+    errors::CompileError, insert_all_files_for_workspace_into_file_manager, package::Package,
+    parse_all, prepare_package, workspace::Workspace,
+};
+use nargo_toml::PackageSelection;
+use noirc_driver::CompileOptions;
+use noirc_frontend::hir::{ParsedFiles, def_map::ModuleId};
+use printer::Printer;
+
+use crate::errors::CliError;
+
+use super::{LockType, PackageOptions, WorkspaceCommand, check_cmd::check_crate_and_report_errors};
+
+mod printer;
+
+/// Expands macros
+#[derive(Debug, Clone, Args)]
+pub(crate) struct ExpandCommand {
+    #[clap(flatten)]
+    pub(super) package_options: PackageOptions,
+
+    #[clap(flatten)]
+    compile_options: CompileOptions,
+}
+
+impl WorkspaceCommand for ExpandCommand {
+    fn package_selection(&self) -> PackageSelection {
+        self.package_options.package_selection()
+    }
+    fn lock_type(&self) -> LockType {
+        // Creates a `Prover.toml` template if it doesn't exist, otherwise only writes if `allow_overwrite` is true,
+        // so it shouldn't lead to accidental conflicts. Doesn't produce compilation artifacts.
+        LockType::None
+    }
+}
+
+pub(crate) fn run(args: ExpandCommand, workspace: Workspace) -> Result<(), CliError> {
+    let mut workspace_file_manager = workspace.new_file_manager();
+    insert_all_files_for_workspace_into_file_manager(&workspace, &mut workspace_file_manager);
+    let parsed_files = parse_all(&workspace_file_manager);
+
+    for package in &workspace {
+        expand_package(&workspace_file_manager, &parsed_files, package, &args.compile_options)?;
+    }
+
+    Ok(())
+}
+
+fn expand_package(
+    file_manager: &FileManager,
+    parsed_files: &ParsedFiles,
+    package: &Package,
+    compile_options: &CompileOptions,
+) -> Result<(), CompileError> {
+    let (mut context, crate_id) = prepare_package(file_manager, parsed_files, package);
+    check_crate_and_report_errors(&mut context, crate_id, compile_options)?;
+
+    let def_map = &context.def_maps[&crate_id];
+    let root_module_id = def_map.root();
+    let module_id = ModuleId { krate: crate_id, local_id: root_module_id };
+
+    let mut string = String::new();
+    let mut printer = Printer::new(crate_id, &context.def_interner, def_map, &mut string);
+    printer.show_module(module_id);
+    printer.show_stray_trait_impls();
+    println!("{}", string);
+
+    Ok(())
+}