feat(nargo): Handle call stacks for multiple Acir calls

compiler/noirc_driver/src/contract.rs

@@ -50,7 +50,7 @@ pub struct ContractFunction {
     )]
     pub bytecode: Program,
 
-    pub debug: DebugInfo,
+    pub debug: Vec<DebugInfo>,
 
     /// Names of the functions in the program. These are used for more informative debugging and benchmarking.
     pub names: Vec<String>,

compiler/noirc_driver/src/lib.rs

@@ -429,7 +429,8 @@ fn compile_contract_inner(
     }
 
     if errors.is_empty() {
-        let debug_infos: Vec<_> = functions.iter().map(|function| function.debug.clone()).collect();
+        let debug_infos: Vec<_> =
+            functions.iter().flat_map(|function| function.debug.clone()).collect();
         let file_map = filter_relevant_files(&debug_infos, &context.file_manager);
 
         Ok(CompiledContract {
@@ -513,13 +514,8 @@ pub fn compile_no_check(
 
     Ok(CompiledProgram {
         hash,
-        // TODO(https://github.com/noir-lang/noir/issues/4428)
         program,
-        // TODO(https://github.com/noir-lang/noir/issues/4428)
-        // Debug info is only relevant for errors at execution time which is not yet supported
-        // The CompileProgram `debug` field is used in multiple places and is better
-        // left to be updated once execution of multiple ACIR functions is enabled
-        debug: debug[0].clone(),
+        debug,
         abi,
         file_map,
         noir_version: NOIR_ARTIFACT_VERSION_STRING.to_string(),

compiler/noirc_driver/src/program.rs

@@ -24,7 +24,7 @@ pub struct CompiledProgram {
     )]
     pub program: Program,
     pub abi: noirc_abi::Abi,
-    pub debug: DebugInfo,
+    pub debug: Vec<DebugInfo>,
     pub file_map: BTreeMap<FileId, DebugFile>,
     pub warnings: Vec<SsaReport>,
     /// Names of the functions in the program. These are used for more informative debugging and benchmarking.

compiler/noirc_errors/src/debug_info.rs

@@ -46,6 +46,50 @@ pub type DebugVariables = BTreeMap<DebugVarId, DebugVariable>;
 pub type DebugFunctions = BTreeMap<DebugFnId, DebugFunction>;
 pub type DebugTypes = BTreeMap<DebugTypeId, PrintableType>;
 
+#[serde_as]
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct ProgramDebugInfo {
+    pub debug_infos: Vec<DebugInfo>,
+}
+
+impl ProgramDebugInfo {
+    pub fn serialize_compressed_base64_json<S>(
+        debug_info: &ProgramDebugInfo,
+        s: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let json_str = serde_json::to_string(debug_info).map_err(S::Error::custom)?;
+
+        let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
+        encoder.write_all(json_str.as_bytes()).map_err(S::Error::custom)?;
+        let compressed_data = encoder.finish().map_err(S::Error::custom)?;
+
+        let encoded_b64 = base64::prelude::BASE64_STANDARD.encode(compressed_data);
+        s.serialize_str(&encoded_b64)
+    }
+
+    pub fn deserialize_compressed_base64_json<'de, D>(
+        deserializer: D,
+    ) -> Result<ProgramDebugInfo, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let encoded_b64: String = Deserialize::deserialize(deserializer)?;
+
+        let compressed_data =
+            base64::prelude::BASE64_STANDARD.decode(encoded_b64).map_err(D::Error::custom)?;
+
+        let mut decoder = DeflateDecoder::new(&compressed_data[..]);
+        let mut decompressed_data = Vec::new();
+        decoder.read_to_end(&mut decompressed_data).map_err(D::Error::custom)?;
+
+        let json_str = String::from_utf8(decompressed_data).map_err(D::Error::custom)?;
+        serde_json::from_str(&json_str).map_err(D::Error::custom)
+    }
+}
+
 #[serde_as]
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct DebugInfo {
@@ -130,40 +174,4 @@ impl DebugInfo {
 
         counted_opcodes
     }
-
-    pub fn serialize_compressed_base64_json<S>(
-        debug_info: &DebugInfo,
-        s: S,
-    ) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let json_str = serde_json::to_string(debug_info).map_err(S::Error::custom)?;
-
-        let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
-        encoder.write_all(json_str.as_bytes()).map_err(S::Error::custom)?;
-        let compressed_data = encoder.finish().map_err(S::Error::custom)?;
-
-        let encoded_b64 = base64::prelude::BASE64_STANDARD.encode(compressed_data);
-        s.serialize_str(&encoded_b64)
-    }
-
-    pub fn deserialize_compressed_base64_json<'de, D>(
-        deserializer: D,
-    ) -> Result<DebugInfo, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let encoded_b64: String = Deserialize::deserialize(deserializer)?;
-
-        let compressed_data =
-            base64::prelude::BASE64_STANDARD.decode(encoded_b64).map_err(D::Error::custom)?;
-
-        let mut decoder = DeflateDecoder::new(&compressed_data[..]);
-        let mut decompressed_data = Vec::new();
-        decoder.read_to_end(&mut decompressed_data).map_err(D::Error::custom)?;
-
-        let json_str = String::from_utf8(decompressed_data).map_err(D::Error::custom)?;
-        serde_json::from_str(&json_str).map_err(D::Error::custom)
-    }
 }

compiler/wasm/src/types/noir_artifact.ts

@@ -128,6 +128,16 @@ export interface DebugInfo {
   locations: Record<OpcodeLocation, SourceCodeLocation[]>;
 }
 
+/**
+ * The debug information for a given program.
+ */
+export interface ProgramDebugInfo {
+  /**
+   * An array that maps to each function of a program.
+   */
+  debug_infos: Array<DebugInfo>;
+}
+
 /**
  * Maps a file ID to its metadata for debugging purposes.
  */

compiler/wasm/test/compiler/shared/compile.test.ts

@@ -5,6 +5,7 @@ import {
   ContractCompilationArtifacts,
   DebugFileMap,
   DebugInfo,
+  ProgramDebugInfo,
   NoirFunctionEntry,
   ProgramArtifact,
   ProgramCompilationArtifacts,
@@ -15,7 +16,7 @@ export function shouldCompileProgramIdentically(
   expect: typeof Expect,
   timeout = 5000,
 ) {
-  it('both nargo and noir_wasm should compile identically', async () => {
+  it('both nargo and noir_wasm should compile program identically', async () => {
     // Compile!
     const { nargoArtifact, noirWasmArtifact } = await compileFn();
 
@@ -51,7 +52,7 @@ export function shouldCompileContractIdentically(
   expect: typeof Expect,
   timeout = 5000,
 ) {
-  it('both nargo and noir_wasm should compile identically', async () => {
+  it('both nargo and noir_wasm should compile contract identically', async () => {
     // Compile!
     const { nargoArtifact, noirWasmArtifact } = await compileFn();
 
@@ -90,7 +91,7 @@ function extractDebugInfos(fns: NoirFunctionEntry[]) {
   return fns.map((fn) => {
     const debugSymbols = inflateDebugSymbols(fn.debug_symbols);
     delete (fn as Partial<NoirFunctionEntry>).debug_symbols;
-    clearFileIdentifiers(debugSymbols);
+    clearFileIdentifiersProgram(debugSymbols);
     return debugSymbols;
   });
 }
@@ -113,6 +114,12 @@ function deleteContractDebugMetadata(contract: ContractArtifact) {
   return [extractDebugInfos(contract.functions), fileMap];
 }
 
+function clearFileIdentifiersProgram(debugSymbols: ProgramDebugInfo) {
+  debugSymbols.debug_infos.map((debug_info) => {
+    clearFileIdentifiers(debug_info);
+  });
+}
+
 /** Clears file identifiers from a set of debug symbols. */
 function clearFileIdentifiers(debugSymbols: DebugInfo) {
   for (const loc of Object.values(debugSymbols.locations)) {

tooling/debugger/src/dap.rs

@@ -603,7 +603,7 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver>(
     initial_witness: WitnessMap,
 ) -> Result<(), ServerError> {
     let debug_artifact = DebugArtifact {
-        debug_symbols: vec![program.debug],
+        debug_symbols: program.debug,
         file_map: program.file_map,
         warnings: program.warnings,
     };

tooling/lsp/src/requests/profile_run.rs

@@ -84,24 +84,29 @@ fn on_profile_run_request_inner(
                 let compiled_program =
                     nargo::ops::transform_program(compiled_program, expression_width);
 
-                let span_opcodes = compiled_program.debug.count_span_opcodes();
-                let debug_artifact: DebugArtifact = compiled_program.clone().into();
-                opcodes_counts.extend(span_opcodes);
+                for function_debug in compiled_program.debug.iter() {
+                    let span_opcodes = function_debug.count_span_opcodes();
+                    opcodes_counts.extend(span_opcodes);
+                }
+                let debug_artifact: DebugArtifact = compiled_program.into();
                 file_map.extend(debug_artifact.file_map);
             }
 
             for compiled_contract in compiled_contracts {
                 let compiled_contract =
                     nargo::ops::transform_contract(compiled_contract, expression_width);
 
-                let function_debug_info: Vec<_> =
-                    compiled_contract.functions.iter().map(|func| &func.debug).cloned().collect();
-                let debug_artifact: DebugArtifact = compiled_contract.into();
-                file_map.extend(debug_artifact.file_map);
+                let function_debug_info = compiled_contract
+                    .functions
+                    .iter()
+                    .flat_map(|func| &func.debug)
+                    .collect::<Vec<_>>();
                 for contract_function_debug in function_debug_info {
                     let span_opcodes = contract_function_debug.count_span_opcodes();
                     opcodes_counts.extend(span_opcodes);
                 }
+                let debug_artifact: DebugArtifact = compiled_contract.into();
+                file_map.extend(debug_artifact.file_map);
             }
 
             let result = NargoProfileRunResult { file_map, opcodes_counts };

tooling/nargo/src/artifacts/contract.rs

@@ -4,7 +4,7 @@ use noirc_driver::{CompiledContract, ContractFunction};
 use serde::{Deserialize, Serialize};
 
 use noirc_driver::DebugFile;
-use noirc_errors::debug_info::DebugInfo;
+use noirc_errors::debug_info::ProgramDebugInfo;
 use std::collections::BTreeMap;
 
 use fm::FileId;
@@ -56,10 +56,10 @@ pub struct ContractFunctionArtifact {
     pub bytecode: Program,
 
     #[serde(
-        serialize_with = "DebugInfo::serialize_compressed_base64_json",
-        deserialize_with = "DebugInfo::deserialize_compressed_base64_json"
+        serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
+        deserialize_with = "ProgramDebugInfo::deserialize_compressed_base64_json"
     )]
-    pub debug_symbols: DebugInfo,
+    pub debug_symbols: ProgramDebugInfo,
 }
 
 impl From<ContractFunction> for ContractFunctionArtifact {
@@ -70,7 +70,7 @@ impl From<ContractFunction> for ContractFunctionArtifact {
             custom_attributes: func.custom_attributes,
             abi: func.abi,
             bytecode: func.bytecode,
-            debug_symbols: func.debug,
+            debug_symbols: ProgramDebugInfo { debug_infos: func.debug },
         }
     }
 }

tooling/nargo/src/artifacts/debug.rs

@@ -121,7 +121,7 @@ impl DebugArtifact {
 impl From<CompiledProgram> for DebugArtifact {
     fn from(compiled_program: CompiledProgram) -> Self {
         DebugArtifact {
-            debug_symbols: vec![compiled_program.debug],
+            debug_symbols: compiled_program.debug,
             file_map: compiled_program.file_map,
             warnings: compiled_program.warnings,
         }
@@ -133,7 +133,7 @@ impl From<CompiledContract> for DebugArtifact {
         let all_functions_debug: Vec<DebugInfo> = compiled_artifact
             .functions
             .into_iter()
-            .map(|contract_function| contract_function.debug)
+            .flat_map(|contract_function| contract_function.debug)
             .collect();
 
         DebugArtifact {

tooling/nargo/src/artifacts/program.rs

@@ -5,7 +5,7 @@ use fm::FileId;
 use noirc_abi::Abi;
 use noirc_driver::CompiledProgram;
 use noirc_driver::DebugFile;
-use noirc_errors::debug_info::DebugInfo;
+use noirc_errors::debug_info::ProgramDebugInfo;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -27,10 +27,10 @@ pub struct ProgramArtifact {
     pub bytecode: Program,
 
     #[serde(
-        serialize_with = "DebugInfo::serialize_compressed_base64_json",
-        deserialize_with = "DebugInfo::deserialize_compressed_base64_json"
+        serialize_with = "ProgramDebugInfo::serialize_compressed_base64_json",
+        deserialize_with = "ProgramDebugInfo::deserialize_compressed_base64_json"
     )]
-    pub debug_symbols: DebugInfo,
+    pub debug_symbols: ProgramDebugInfo,
 
     /// Map of file Id to the source code so locations in debug info can be mapped to source code they point to.
     pub file_map: BTreeMap<FileId, DebugFile>,
@@ -45,7 +45,7 @@ impl From<CompiledProgram> for ProgramArtifact {
             abi: compiled_program.abi,
             noir_version: compiled_program.noir_version,
             bytecode: compiled_program.program,
-            debug_symbols: compiled_program.debug,
+            debug_symbols: ProgramDebugInfo { debug_infos: compiled_program.debug },
             file_map: compiled_program.file_map,
             names: compiled_program.names,
         }
@@ -59,7 +59,7 @@ impl From<ProgramArtifact> for CompiledProgram {
             abi: program.abi,
             noir_version: program.noir_version,
             program: program.bytecode,
-            debug: program.debug_symbols,
+            debug: program.debug_symbols.debug_infos,
             file_map: program.file_map,
             warnings: vec![],
             names: program.names,