Merge branch 'master' into gd/issue_1412

* master:
  chore: rename `ssa_refactor` module to `ssa` (#2129)
  chore: Use `--show-output` flag on execution rather than compilation  (#2116)
  fix(globals): Accurately filter literals for resolving globals (#2126)
  feat: Optimize away constant calls to black box functions (#1981)
  fix: Rename `Option::value` to `Option::_value` (#2127)
  feat: replace boolean `AND`s with multiplication (#1954)
  chore: create a `const` to hold the panic message (#2122)
  feat: Add support for bitshifts by distances known at runtime (#2072)
  feat: Add additional `BinaryOp` simplifications (#2124)
  fix: flattening pass no longer overwrites previously mapped condition values (#2117)
  chore(noirc_driver): Unify crate preparation (#2119)

.gitignore

@@ -22,5 +22,3 @@ result
 **/target
 !crates/nargo_cli/tests/test_data/*/target
 !crates/nargo_cli/tests/test_data/*/target/witness.tr
-!crates/nargo_cli/tests/test_data_ssa_refactor/*/target
-!crates/nargo_cli/tests/test_data_ssa_refactor/*/target/witness.tr

crates/lsp/src/lib.rs

@@ -22,7 +22,7 @@ use lsp_types::{
     InitializeParams, InitializeResult, InitializedParams, Position, PublishDiagnosticsParams,
     Range, ServerCapabilities, TextDocumentSyncOptions,
 };
-use noirc_driver::{check_crate, create_local_crate};
+use noirc_driver::{check_crate, prepare_crate};
 use noirc_errors::{DiagnosticKind, FileDiagnostic};
 use noirc_frontend::{
     graph::{CrateGraph, CrateType},
@@ -190,7 +190,7 @@ fn on_code_lens_request(
         }
     };
 
-    let crate_id = create_local_crate(&mut context, file_path, CrateType::Binary);
+    let crate_id = prepare_crate(&mut context, file_path, CrateType::Binary);
 
     // We ignore the warnings and errors produced by compilation for producing codelenses
     // because we can still get the test functions even if compilation fails
@@ -283,7 +283,7 @@ fn on_did_save_text_document(
         }
     };
 
-    let crate_id = create_local_crate(&mut context, file_path, CrateType::Binary);
+    let crate_id = prepare_crate(&mut context, file_path, CrateType::Binary);
 
     let mut diagnostics = Vec::new();
 

crates/lsp/src/lib_hacky.rs

@@ -19,7 +19,7 @@ use lsp_types::{
     InitializedParams, Position, PublishDiagnosticsParams, Range, ServerCapabilities,
     TextDocumentSyncOptions,
 };
-use noirc_driver::{check_crate, create_local_crate, create_non_local_crate, propagate_dep};
+use noirc_driver::{check_crate, prepare_crate, propagate_dep};
 use noirc_errors::{DiagnosticKind, FileDiagnostic};
 use noirc_frontend::{
     graph::{CrateGraph, CrateId, CrateType},
@@ -286,7 +286,7 @@ fn create_context_at_path(
     }
     let nargo_toml_path = find_nearest_parent_file(&file_path, &["Nargo.toml"]);
 
-    let current_crate_id = create_local_crate(&mut context, &file_path, CrateType::Binary);
+    let current_crate_id = prepare_crate(&mut context, &file_path, CrateType::Binary);
 
     // TODO(AD): undo hacky dependency resolution
     if let Some(nargo_toml_path) = nargo_toml_path {
@@ -297,8 +297,7 @@ fn create_context_at_path(
                     .parent()
                     .unwrap() // TODO
                     .join(PathBuf::from(&dependency_path).join("src").join("lib.nr"));
-                let library_crate =
-                    create_non_local_crate(&mut context, &path_to_lib, CrateType::Library);
+                let library_crate = prepare_crate(&mut context, &path_to_lib, CrateType::Library);
                 propagate_dep(&mut context, library_crate, &crate_name.parse().unwrap());
             }
         }

crates/nargo/src/ops/execute.rs

@@ -10,6 +10,7 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver + Default>(
     _backend: &B,
     circuit: Circuit,
     initial_witness: WitnessMap,
+    show_output: bool,
 ) -> Result<WitnessMap, NargoError> {
     let mut acvm = ACVM::new(B::default(), circuit.opcodes, initial_witness);
 
@@ -23,7 +24,7 @@ pub fn execute_circuit<B: BlackBoxFunctionSolver + Default>(
             }
             ACVMStatus::Failure(error) => return Err(error.into()),
             ACVMStatus::RequiresForeignCall(foreign_call) => {
-                let foreign_call_result = ForeignCall::execute(&foreign_call)?;
+                let foreign_call_result = ForeignCall::execute(&foreign_call, show_output)?;
                 acvm.resolve_pending_foreign_call(foreign_call_result);
             }
         }

crates/nargo/src/ops/foreign_calls.rs

@@ -42,11 +42,14 @@ impl ForeignCall {
 
     pub(crate) fn execute(
         foreign_call: &ForeignCallWaitInfo,
+        show_output: bool,
     ) -> Result<ForeignCallResult, ForeignCallError> {
         let foreign_call_name = foreign_call.function.as_str();
         match Self::lookup(foreign_call_name) {
             Some(ForeignCall::Println) => {
-                Self::execute_println(&foreign_call.inputs)?;
+                if show_output {
+                    Self::execute_println(&foreign_call.inputs)?;
+                }
                 Ok(ForeignCallResult { values: vec![] })
             }
             Some(ForeignCall::Sequence) => {

crates/nargo_cli/src/cli/execute_cmd.rs

@@ -133,7 +133,7 @@ pub(crate) fn execute_program<B: Backend>(
     debug_data: Option<(DebugInfo, Context)>,
 ) -> Result<WitnessMap, CliError<B>> {
     let initial_witness = abi.encode(inputs_map, None)?;
-    let solved_witness_err = nargo::ops::execute_circuit(backend, circuit, initial_witness);
+    let solved_witness_err = nargo::ops::execute_circuit(backend, circuit, initial_witness, true);
     match solved_witness_err {
         Ok(solved_witness) => Ok(solved_witness),
         Err(err) => {

crates/nargo_cli/src/cli/mod.rs

@@ -92,7 +92,7 @@ pub fn start_cli() -> eyre::Result<()> {
 #[cfg(test)]
 mod tests {
     use fm::FileManager;
-    use noirc_driver::{check_crate, create_local_crate};
+    use noirc_driver::{check_crate, prepare_crate};
     use noirc_errors::reporter;
     use noirc_frontend::{
         graph::{CrateGraph, CrateType},
@@ -110,7 +110,7 @@ mod tests {
         let fm = FileManager::new(root_dir);
         let graph = CrateGraph::default();
         let mut context = Context::new(fm, graph);
-        let crate_id = create_local_crate(&mut context, root_file, CrateType::Binary);
+        let crate_id = prepare_crate(&mut context, root_file, CrateType::Binary);
 
         let result = check_crate(&mut context, crate_id, false);
         let success = result.is_ok();

crates/nargo_cli/src/cli/test_cmd.rs

@@ -106,14 +106,17 @@ fn run_test<B: Backend>(
     show_output: bool,
     config: &CompileOptions,
 ) -> Result<(), CliError<B>> {
-    let mut program = compile_no_check(context, show_output, config, main)
-        .map_err(|_| CliError::Generic(format!("Test '{test_name}' failed to compile")))?;
+    let mut program = compile_no_check(context, config, main).map_err(|err| {
+        noirc_errors::reporter::report_all(&context.file_manager, &[err], config.deny_warnings);
+        CliError::Generic(format!("Test '{test_name}' failed to compile"))
+    })?;
+
     // Note: We could perform this test using the unoptimized ACIR as generated by `compile_no_check`.
     program.circuit = optimize_circuit(backend, program.circuit).unwrap().0;
 
     // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,
     // otherwise constraints involving these expressions will not error.
-    match execute_circuit(backend, program.circuit, WitnessMap::new()) {
+    match execute_circuit(backend, program.circuit, WitnessMap::new(), show_output) {
         Ok(_) => Ok(()),
         Err(error) => {
             let writer = StandardStream::stderr(ColorChoice::Always);

crates/nargo_cli/src/lib.rs

@@ -9,7 +9,7 @@
 
 use fm::FileManager;
 use nargo::package::{Dependency, Package};
-use noirc_driver::{add_dep, create_local_crate, create_non_local_crate};
+use noirc_driver::{add_dep, prepare_crate};
 use noirc_frontend::{
     graph::{CrateGraph, CrateId, CrateName, CrateType},
     hir::Context,
@@ -107,8 +107,7 @@ fn prepare_dependencies(
     for (dep_name, dep) in dependencies.into_iter() {
         match dep {
             Dependency::Remote { package } | Dependency::Local { package } => {
-                let crate_id =
-                    create_non_local_crate(context, &package.entry_path, package.crate_type);
+                let crate_id = prepare_crate(context, &package.entry_path, package.crate_type);
                 add_dep(context, parent_crate, crate_id, dep_name);
                 prepare_dependencies(context, crate_id, package.dependencies.to_owned());
             }
@@ -121,7 +120,7 @@ fn prepare_package(package: &Package) -> (Context, CrateId) {
     let graph = CrateGraph::default();
     let mut context = Context::new(fm, graph);
 
-    let crate_id = create_local_crate(&mut context, &package.entry_path, package.crate_type);
+    let crate_id = prepare_crate(&mut context, &package.entry_path, package.crate_type);
 
     prepare_dependencies(&mut context, crate_id, package.dependencies.to_owned());
 

crates/nargo_cli/src/main.rs

@@ -3,12 +3,12 @@
 use color_eyre::{config::HookBuilder, eyre};
 use nargo_cli::cli::start_cli;
 
+const PANIC_MESSAGE: &str = "This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml";
+
 fn main() -> eyre::Result<()> {
     // Register a panic hook to display more readable panic messages to end-users
-    let (panic_hook, _) = HookBuilder::default()
-        .display_env_section(false)
-        .panic_section("This is a bug. We may have already fixed this in newer versions of Nargo so try searching for similar issues at https://github.com/noir-lang/noir/issues/.\nIf there isn't an open issue for this bug, consider opening one at https://github.com/noir-lang/noir/issues/new?labels=bug&template=bug_report.yml")
-        .into_hooks();
+    let (panic_hook, _) =
+        HookBuilder::default().display_env_section(false).panic_section(PANIC_MESSAGE).into_hooks();
     panic_hook.install();
 
     start_cli()

crates/nargo_cli/tests/test_data/bit_shifts_runtime/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "bit_shifts_runtime"
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

crates/nargo_cli/tests/test_data/bit_shifts_runtime/Prover.toml

@@ -0,0 +1,2 @@
+x = 64
+y = 1

crates/nargo_cli/tests/test_data/bit_shifts_runtime/src/main.nr

@@ -0,0 +1,9 @@
+fn main(x: u64, y: u64) {
+	// runtime shifts on comptime values
+	assert(64 << y == 128);
+	assert(64 >> y == 32);
+
+	// runtime shifts on runtime values
+	assert(x << y == 128);
+	assert(x >> y == 32);
+}

crates/nargo_cli/tests/test_data/global_consts/src/main.nr

@@ -12,12 +12,19 @@ struct Dummy {
      y: [Field; foo::MAGIC_NUMBER]
 }
 
+struct Test {
+    v: Field,
+}
+global VALS: [Test; 1] = [Test { v: 100 }];
+global NESTED = [VALS, VALS];
+
 fn main(a: [Field; M + N - N], b: [Field; 30 + N / 2], c : pub [Field; foo::MAGIC_NUMBER], d: [Field; foo::bar::N]) {
      let test_struct = Dummy { x: d, y: c };
 
      for i in 0..foo::MAGIC_NUMBER {
           assert(c[i] == foo::MAGIC_NUMBER);
           assert(test_struct.y[i] == foo::MAGIC_NUMBER);
+          assert(test_struct.y[i] != NESTED[1][0].v);
      }
 
      assert(N != M);

crates/nargo_cli/tests/test_data/regression_2099/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_2099"
+authors = [""]
+compiler_version = "0.9.0"
+
+[dependencies]

crates/nargo_cli/tests/test_data/regression_2099/src/main.nr

@@ -0,0 +1,37 @@
+use dep::std::ec::tecurve::affine::Curve as AffineCurve;
+use dep::std::ec::tecurve::affine::Point as Gaffine;
+use dep::std::ec::tecurve::curvegroup::Curve;
+use dep::std::ec::tecurve::curvegroup::Point as G;
+
+use dep::std::ec::swcurve::affine::Point as SWGaffine;
+use dep::std::ec::swcurve::curvegroup::Point as SWG;
+
+use dep::std::ec::montcurve::affine::Point as MGaffine;
+use dep::std::ec::montcurve::curvegroup::Point as MG;
+
+fn main() {
+    // Define Baby Jubjub (ERC-2494) parameters in affine representation
+    let bjj_affine = AffineCurve::new(168700, 168696, Gaffine::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));
+
+    // Test addition
+    let p1_affine = Gaffine::new(17777552123799933955779906779655732241715742912184938656739573121738514868268, 2626589144620713026669568689430873010625803728049924121243784502389097019475);
+    let p2_affine = Gaffine::new(16540640123574156134436876038791482806971768689494387082833631921987005038935, 20819045374670962167435360035096875258406992893633759881276124905556507972311);      
+    let _p3_affine = bjj_affine.add(p1_affine, p2_affine);
+
+    // Test SWCurve equivalents of the above
+    // First the affine representation
+    let bjj_swcurve_affine = bjj_affine.into_swcurve();
+
+    let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine);
+    let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine);
+
+    let _p3_swcurve_affine_from_add = bjj_swcurve_affine.add(
+        p1_swcurve_affine,
+        p2_swcurve_affine
+    );
+
+    // Check that these points are on the curve
+    assert(
+        bjj_swcurve_affine.contains(p1_swcurve_affine)
+    );            
+}

crates/nargo_cli/tests/test_data/strings/src/main.nr

@@ -1,10 +1,13 @@
 use dep::std;
 
+// Test global string literals
+global HELLO_WORLD = "hello world";
+
 fn main(message : pub str<11>, y : Field, hex_as_string : str<4>, hex_as_field : Field) {
     let mut bad_message = "hello world";
 
     assert(message == "hello world");
-    bad_message = "helld world";
+    assert(message == HELLO_WORLD);
     let x = 10;
     let z = x * 5;
     std::println(10);
@@ -16,6 +19,7 @@ fn main(message : pub str<11>, y : Field, hex_as_string : str<4>, hex_as_field :
     assert(y == 5); // Change to y != 5 to see how the later print statements are not called
     std::println(array);
 
+    bad_message = "helld world";
     std::println(bad_message);
     assert(message != bad_message);
 
@@ -39,16 +43,30 @@ fn test_prints_strings() {
 fn test_prints_array() {
     let array = [1, 2, 3, 5, 8];
 
-    // TODO: Printing structs currently not supported
-    // let s = Test { a: 1, b: 2, c: [3, 4] };
-    // std::println(s);
+    let s = Test { a: 1, b: 2, c: [3, 4] };
+    std::println(s);
 
     std::println(array);
 
     let hash = std::hash::pedersen(array);
     std::println(hash);
 }
 
+fn failed_constraint(hex_as_field: Field) {
+    // TODO(#2116): Note that `println` will not work if a failed constraint can be 
+    // evaluated at compile time. 
+    // When this method is called from a test method or with constant values
+    // a `Failed constraint` compile error will be caught before this `println`
+    // is executed as the input will be a constant. 
+    std::println(hex_as_field);
+    assert(hex_as_field != 0x41);
+}
+
+#[test]
+fn test_failed_constraint() {
+    failed_constraint(0x41);
+}
+
 struct Test {
     a: Field,
     b: Field,