reintroduce compile_circuit function

noir-lang · Jul 26, 2023 · cd11b28 · cd11b28
1 parent 5333196
commit cd11b28
Show file tree

Hide file tree

Showing 6 changed files with 55 additions and 64 deletions.
diff --git a/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs b/crates/nargo_cli/src/cli/codegen_verifier_cmd.rs
@@ -8,13 +8,13 @@ use super::fs::{
     write_to_file,
 };
 use super::NargoConfig;
-use crate::errors::CliError;
+use crate::manifest::resolve_workspace;
 use crate::resolver::prepare_package;
-use crate::{cli::compile_cmd::report_errors, manifest::resolve_workspace};
+use crate::{cli::compile_cmd::compile_circuit, errors::CliError};
 use acvm::Backend;
 use clap::Args;
 use nargo::ops::{codegen_verifier, preprocess_program};
-use noirc_driver::{compile_main, CompileOptions};
+use noirc_driver::CompileOptions;
 use noirc_frontend::graph::CrateName;
 
 /// Generates a Solidity verifier smart contract for the program
@@ -50,8 +50,8 @@ pub(crate) fn run<B: Backend>(
             }
             None => {
                 let (mut context, crate_id) = prepare_package(package);
-                let result = compile_main(&mut context, crate_id, &args.compile_options);
-                let program = report_errors(result, &context, args.compile_options.deny_warnings)?;
+                let program =
+                    compile_circuit(backend, &mut context, crate_id, &args.compile_options)?;
                 let common_reference_string = update_common_reference_string(
                     backend,
                     &common_reference_string,

diff --git a/crates/nargo_cli/src/cli/compile_cmd.rs b/crates/nargo_cli/src/cli/compile_cmd.rs
@@ -3,9 +3,11 @@ use acvm::{acir::circuit::Circuit, Backend};
 use iter_extended::try_vecmap;
 use iter_extended::vecmap;
 use nargo::{artifacts::contract::PreprocessedContract, NargoError};
-use noirc_driver::{compile_contracts, compile_main, CompileOptions, ErrorsAndWarnings, Warnings};
+use noirc_driver::{
+    compile_contracts, compile_main, CompileOptions, CompiledProgram, ErrorsAndWarnings, Warnings,
+};
 use noirc_errors::reporter::ReportedErrors;
-use noirc_frontend::graph::CrateName;
+use noirc_frontend::graph::{CrateId, CrateName};
 use noirc_frontend::hir::Context;
 
 use clap::Args;
@@ -108,22 +110,7 @@ pub(crate) fn run<B: Backend>(
     } else {
         for package in &workspace {
             let (mut context, crate_id) = prepare_package(package);
-            let result = compile_main(&mut context, crate_id, &args.compile_options);
-            let mut program = report_errors(result, &context, args.compile_options.deny_warnings)?;
-            // Apply backend specific optimizations.
-            let (optimized_circuit, opcode_labels) = optimize_circuit(backend, program.circuit)
-                .expect("Backend does not support an opcode that is in the IR");
-
-            // TODO: Why does this set `program.circuit` to `optimized_circuit` instead of the function taking ownership
-            // and requiring we use `optimized_circuit` everywhere after
-            program.circuit = optimized_circuit;
-            let opcode_ids = vecmap(opcode_labels, |label| match label {
-                OpcodeLabel::Unresolved => {
-                    unreachable!("Compiled circuit opcodes must resolve to some index")
-                }
-                OpcodeLabel::Resolved(index) => index as usize,
-            });
-            program.debug.update_acir(opcode_ids);
+            let program = compile_circuit(backend, &mut context, crate_id, &args.compile_options)?;
 
             common_reference_string =
                 update_common_reference_string(backend, &common_reference_string, &program.circuit)
@@ -141,21 +128,31 @@ pub(crate) fn run<B: Backend>(
     Ok(())
 }
 
-// pub(crate) fn compile_package<P>(
-//     package: &Package,
-//     compile: fn(
-//         context: &mut Context,
-//         crate_id: CrateId,
-//         options: &CompileOptions,
-//     ) -> Result<(P, Warnings), ErrorsAndWarnings>,
-//     compile_options: &CompileOptions,
-// ) -> Result<P, ReportedErrors> {
-//     let (mut context, crate_id) = prepare_package(package);
-//     let result = compile(&mut context, crate_id, compile_options);
-//     let program = report_errors(result, &context, compile_options.deny_warnings)?;
-
-//     Ok(program)
-// }
+pub(crate) fn compile_circuit<B: Backend>(
+    backend: &B,
+    context: &mut Context,
+    crate_id: CrateId,
+    compile_options: &CompileOptions,
+) -> Result<CompiledProgram, ReportedErrors> {
+    let result = compile_main(context, crate_id, compile_options);
+    let mut program = report_errors(result, context, compile_options.deny_warnings)?;
+    // Apply backend specific optimizations.
+    let (optimized_circuit, opcode_labels) = optimize_circuit(backend, program.circuit)
+        .expect("Backend does not support an opcode that is in the IR");
+
+    // TODO: Why does this set `program.circuit` to `optimized_circuit` instead of the function taking ownership
+    // and requiring we use `optimized_circuit` everywhere after
+    program.circuit = optimized_circuit;
+    let opcode_ids = vecmap(opcode_labels, |label| match label {
+        OpcodeLabel::Unresolved => {
+            unreachable!("Compiled circuit opcodes must resolve to some index")
+        }
+        OpcodeLabel::Resolved(index) => index as usize,
+    });
+    program.debug.update_acir(opcode_ids);
+
+    Ok(program)
+}
 
 pub(super) fn optimize_circuit<B: Backend>(
     backend: &B,

diff --git a/crates/nargo_cli/src/cli/execute_cmd.rs b/crates/nargo_cli/src/cli/execute_cmd.rs
@@ -7,12 +7,12 @@ use nargo::package::Package;
 use nargo::NargoError;
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::{Abi, InputMap};
-use noirc_driver::{compile_main, CompileOptions, CompiledProgram};
+use noirc_driver::{CompileOptions, CompiledProgram};
 use noirc_errors::{debug_info::DebugInfo, CustomDiagnostic};
 use noirc_frontend::graph::CrateName;
 use noirc_frontend::hir::Context;
 
-use super::compile_cmd::report_errors;
+use super::compile_cmd::compile_circuit;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
 use crate::errors::CliError;
@@ -69,8 +69,7 @@ fn execute_package<B: Backend>(
     compile_options: &CompileOptions,
 ) -> Result<(Option<InputValue>, WitnessMap), CliError<B>> {
     let (mut context, crate_id) = prepare_package(package);
-    let result = compile_main(&mut context, crate_id, compile_options);
-    let compiled_program = report_errors(result, &context, compile_options.deny_warnings)?;
+    let compiled_program = compile_circuit(backend, &mut context, crate_id, compile_options)?;
     let CompiledProgram { abi, circuit, debug } = compiled_program;
 
     // Parse the initial witness values from Prover.toml

diff --git a/crates/nargo_cli/src/cli/gates_cmd.rs b/crates/nargo_cli/src/cli/gates_cmd.rs
@@ -1,11 +1,11 @@
 use acvm::Backend;
 use clap::Args;
 use nargo::package::Package;
-use noirc_driver::{compile_main, CompileOptions};
+use noirc_driver::CompileOptions;
 use noirc_frontend::graph::CrateName;
 
 use crate::{
-    cli::compile_cmd::report_errors, errors::CliError, manifest::resolve_workspace,
+    cli::compile_cmd::compile_circuit, errors::CliError, manifest::resolve_workspace,
     resolver::prepare_package,
 };
 
@@ -41,8 +41,7 @@ fn count_gates_in_package<B: Backend>(
     compile_options: &CompileOptions,
 ) -> Result<(), CliError<B>> {
     let (mut context, crate_id) = prepare_package(package);
-    let result = compile_main(&mut context, crate_id, compile_options);
-    let compiled_program = report_errors(result, &context, compile_options.deny_warnings)?;
+    let compiled_program = compile_circuit(backend, &mut context, crate_id, compile_options)?;
 
     let num_opcodes = compiled_program.circuit.opcodes.len();
 

diff --git a/crates/nargo_cli/src/cli/prove_cmd.rs b/crates/nargo_cli/src/cli/prove_cmd.rs
@@ -7,10 +7,10 @@ use nargo::constants::{PROVER_INPUT_FILE, VERIFIER_INPUT_FILE};
 use nargo::ops::{preprocess_program, prove_execution, verify_proof};
 use nargo::package::Package;
 use noirc_abi::input_parser::Format;
-use noirc_driver::{compile_main, CompileOptions};
+use noirc_driver::CompileOptions;
 use noirc_frontend::graph::CrateName;
 
-use super::compile_cmd::report_errors;
+use super::compile_cmd::compile_circuit;
 use super::fs::{
     common_reference_string::{
         read_cached_common_reference_string, update_common_reference_string,
@@ -104,8 +104,7 @@ pub(crate) fn prove_with_path<B: Backend>(
         }
         None => {
             let (mut context, crate_id) = prepare_package(package);
-            let result = compile_main(&mut context, crate_id, compile_options);
-            let program = report_errors(result, &context, compile_options.deny_warnings)?;
+            let program = compile_circuit(backend, &mut context, crate_id, compile_options)?;
             let common_reference_string =
                 update_common_reference_string(backend, &common_reference_string, &program.circuit)
                     .map_err(CliError::CommonReferenceStringError)?;

diff --git a/crates/nargo_cli/src/cli/verify_cmd.rs b/crates/nargo_cli/src/cli/verify_cmd.rs
@@ -1,16 +1,14 @@
-use super::NargoConfig;
-use super::{
-    compile_cmd::report_errors,
-    fs::{
-        common_reference_string::{
-            read_cached_common_reference_string, update_common_reference_string,
-            write_cached_common_reference_string,
-        },
-        inputs::read_inputs_from_file,
-        load_hex_data,
-        program::read_program_from_file,
+use super::compile_cmd::compile_circuit;
+use super::fs::{
+    common_reference_string::{
+        read_cached_common_reference_string, update_common_reference_string,
+        write_cached_common_reference_string,
     },
+    inputs::read_inputs_from_file,
+    load_hex_data,
+    program::read_program_from_file,
 };
+use super::NargoConfig;
 use crate::manifest::resolve_workspace;
 use crate::{errors::CliError, resolver::prepare_package};
 
@@ -20,7 +18,7 @@ use nargo::constants::{PROOF_EXT, VERIFIER_INPUT_FILE};
 use nargo::ops::{preprocess_program, verify_proof};
 use nargo::{artifacts::program::PreprocessedProgram, package::Package};
 use noirc_abi::input_parser::Format;
-use noirc_driver::{compile_main, CompileOptions};
+use noirc_driver::CompileOptions;
 use noirc_frontend::graph::CrateName;
 use std::path::Path;
 
@@ -89,8 +87,7 @@ fn verify_with_path<B: Backend, P: AsRef<Path>>(
         }
         None => {
             let (mut context, crate_id) = prepare_package(package);
-            let result = compile_main(&mut context, crate_id, compile_options);
-            let program = report_errors(result, &context, compile_options.deny_warnings)?;
+            let program = compile_circuit(backend, &mut context, crate_id, compile_options)?;
             let common_reference_string =
                 update_common_reference_string(backend, &common_reference_string, &program.circuit)
                     .map_err(CliError::CommonReferenceStringError)?;