feat: short-circuit compilation and read build artifacts from file if…

… program is unchanged (#2743)

Cargo.toml

@@ -71,3 +71,4 @@ url = "2.2.0"
 wasm-bindgen = { version = "=0.2.86", features = ["serde-serialize"] }
 wasm-bindgen-test = "0.3.33"
 base64 = "0.21.2"
+fxhash = "0.2.1"

compiler/noirc_driver/Cargo.toml

@@ -17,3 +17,4 @@ acvm.workspace = true
 fm.workspace = true
 serde.workspace = true
 base64.workspace = true
+fxhash.workspace = true

compiler/noirc_driver/src/lib.rs

@@ -58,7 +58,7 @@ pub type CompilationResult<T> = Result<(T, Warnings), ErrorsAndWarnings>;
 // with the restricted version which only uses one file
 pub fn compile_file(context: &mut Context, root_file: &Path) -> CompilationResult<CompiledProgram> {
     let crate_id = prepare_crate(context, root_file);
-    compile_main(context, crate_id, &CompileOptions::default())
+    compile_main(context, crate_id, &CompileOptions::default(), None)
 }
 
 /// Adds the file from the file system at `Path` to the crate graph as a root file
@@ -143,6 +143,7 @@ pub fn compile_main(
     context: &mut Context,
     crate_id: CrateId,
     options: &CompileOptions,
+    cached_program: Option<CompiledProgram>,
 ) -> CompilationResult<CompiledProgram> {
     let (_, warnings) = check_crate(context, crate_id, options.deny_warnings)?;
 
@@ -158,7 +159,7 @@ pub fn compile_main(
         }
     };
 
-    let compiled_program = compile_no_check(context, options, main)?;
+    let compiled_program = compile_no_check(context, options, main, cached_program)?;
 
     if options.print_acir {
         println!("Compiled ACIR for main (unoptimized):");
@@ -252,7 +253,7 @@ fn compile_contract_inner(
             continue;
         }
 
-        let function = match compile_no_check(context, options, function_id) {
+        let function = match compile_no_check(context, options, function_id, None) {
             Ok(function) => function,
             Err(new_error) => {
                 errors.push(new_error);
@@ -295,13 +296,21 @@ pub fn compile_no_check(
     context: &Context,
     options: &CompileOptions,
     main_function: FuncId,
+    cached_program: Option<CompiledProgram>,
 ) -> Result<CompiledProgram, FileDiagnostic> {
     let program = monomorphize(main_function, &context.def_interner);
 
+    let hash = fxhash::hash64(&program);
+    if let Some(cached_program) = cached_program {
+        if hash == cached_program.hash {
+            return Ok(cached_program);
+        }
+    }
+
     let (circuit, debug, abi) =
         create_circuit(context, program, options.show_ssa, options.show_brillig)?;
 
     let file_map = filter_relevant_files(&[debug.clone()], &context.file_manager);
 
-    Ok(CompiledProgram { circuit, debug, abi, file_map })
+    Ok(CompiledProgram { hash, circuit, debug, abi, file_map })
 }

compiler/noirc_driver/src/program.rs

@@ -11,6 +11,12 @@ use super::debug::DebugFile;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct CompiledProgram {
+    /// Hash of the [`Program`][noirc_frontend::monomorphization::ast::Program] from which this [`CompiledProgram`]
+    /// was compiled.
+    ///
+    /// Used to short-circuit compilation in the case of the source code not changing since the last compilation.
+    pub hash: u64,
+
     #[serde(serialize_with = "serialize_circuit", deserialize_with = "deserialize_circuit")]
     pub circuit: Circuit,
     pub abi: noirc_abi::Abi,

compiler/noirc_evaluator/Cargo.toml

@@ -12,7 +12,7 @@ noirc_frontend.workspace = true
 noirc_errors.workspace = true
 noirc_abi.workspace = true
 acvm.workspace = true
-fxhash = "0.2.1"
+fxhash.workspace = true
 iter-extended.workspace = true
 thiserror.workspace = true
 num-bigint = "0.4"

compiler/noirc_frontend/src/ast/mod.rs

@@ -259,7 +259,7 @@ impl UnresolvedTypeExpression {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 /// Represents whether the parameter is public or known only to the prover.
 pub enum Visibility {
     Public,
@@ -277,7 +277,7 @@ impl std::fmt::Display for Visibility {
     }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 /// Represents whether the return value should compromise of unique witness indices such that no
 /// index occurs within the program's abi more than once.
 ///

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -41,7 +41,7 @@ impl HirExpression {
 }
 
 /// Corresponds to a variable in the source code
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct HirIdent {
     pub location: Location,
     pub id: DefinitionId,

compiler/noirc_frontend/src/hir_def/stmt.rs

@@ -48,7 +48,7 @@ pub struct HirAssignStatement {
 #[derive(Debug, Clone)]
 pub struct HirConstrainStatement(pub ExprId, pub FileId, pub Option<String>);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub enum HirPattern {
     Identifier(HirIdent),
     Mutable(Box<HirPattern>, Span),

compiler/noirc_frontend/src/monomorphization/ast.rs

@@ -14,7 +14,7 @@ use crate::{hir_def::function::FunctionSignature, BinaryOpKind, Distinctness, Si
 ///   e.g. `let (a, b) = (1, 2)` have been split up: `let tmp = (1, 2); let a = tmp.0; let b = tmp.1;`.
 ///   This also affects function parameters: `fn foo((a, b): (i32, i32)` => `fn foo(a: i32, b: i32)`.
 /// - All structs are replaced with tuples
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub enum Expression {
     Ident(Ident),
     Literal(Literal),
@@ -55,7 +55,7 @@ pub struct LocalId(pub u32);
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct FuncId(pub u32);
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Ident {
     pub location: Option<Location>,
     pub definition: Definition,
@@ -64,7 +64,7 @@ pub struct Ident {
     pub typ: Type,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct For {
     pub index_variable: LocalId,
     pub index_name: String,
@@ -78,7 +78,7 @@ pub struct For {
     pub end_range_location: Location,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub enum Literal {
     Array(ArrayLiteral),
     Integer(FieldElement, Type),
@@ -87,7 +87,7 @@ pub enum Literal {
     FmtStr(String, u64, Box<Expression>),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Unary {
     pub operator: crate::UnaryOp,
     pub rhs: Box<Expression>,
@@ -97,7 +97,7 @@ pub struct Unary {
 
 pub type BinaryOp = BinaryOpKind;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Binary {
     pub lhs: Box<Expression>,
     pub operator: BinaryOp,
@@ -111,36 +111,36 @@ pub struct Lambda {
     pub env: Ident,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct If {
     pub condition: Box<Expression>,
     pub consequence: Box<Expression>,
     pub alternative: Option<Box<Expression>>,
     pub typ: Type,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Cast {
     pub lhs: Box<Expression>,
     pub r#type: Type,
     pub location: Location,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct ArrayLiteral {
     pub contents: Vec<Expression>,
     pub typ: Type,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Call {
     pub func: Box<Expression>,
     pub arguments: Vec<Expression>,
     pub return_type: Type,
     pub location: Location,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Index {
     pub collection: Box<Expression>,
     pub index: Box<Expression>,
@@ -160,15 +160,15 @@ pub struct Index {
 /// let field1 = tmp.0; // the struct has been translated to a tuple as well
 /// let field2 = tmp.1;
 /// ```
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Let {
     pub id: LocalId,
     pub mutable: bool,
     pub name: String,
     pub expression: Box<Expression>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Assign {
     pub lvalue: LValue,
     pub expression: Box<Expression>,
@@ -182,7 +182,7 @@ pub struct BinaryStatement {
 }
 
 /// Represents an Ast form that can be assigned to
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub enum LValue {
     Ident(Ident),
     Index { array: Box<LValue>, index: Box<Expression>, element_type: Type, location: Location },
@@ -192,7 +192,7 @@ pub enum LValue {
 
 pub type Parameters = Vec<(LocalId, /*mutable:*/ bool, /*name:*/ String, Type)>;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Function {
     pub id: FuncId,
     pub name: String,
@@ -209,7 +209,7 @@ pub struct Function {
 /// - Concrete lengths for each array and string
 /// - Several other variants removed (such as Type::Constant)
 /// - All structs replaced with tuples
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum Type {
     Field,
     Array(/*len:*/ u64, Box<Type>),     // Array(4, Field) = [Field; 4]
@@ -233,7 +233,7 @@ impl Type {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash)]
 pub struct Program {
     pub functions: Vec<Function>,
     pub main_function_signature: FunctionSignature,

compiler/wasm/src/compile.rs

@@ -125,7 +125,7 @@ pub fn compile(args: JsValue) -> JsValue {
 
         <JsValue as JsValueSerdeExt>::from_serde(&optimized_contract).unwrap()
     } else {
-        let compiled_program = compile_main(&mut context, crate_id, &options.compile_options)
+        let compiled_program = compile_main(&mut context, crate_id, &options.compile_options, None)
             .expect("Compilation failed")
             .0;
 

tooling/nargo/src/artifacts/program.rs

@@ -9,6 +9,12 @@ use serde::{Deserialize, Serialize};
 /// - Proving and verification keys have been pregenerated based on this ACIR.
 #[derive(Serialize, Deserialize, Debug)]
 pub struct PreprocessedProgram {
+    /// Hash of the [`Program`][noirc_frontend::monomorphization::ast::Program] from which this [`PreprocessedProgram`]
+    /// was compiled.
+    ///
+    /// Used to short-circuit compilation in the case of the source code not changing since the last compilation.
+    pub hash: u64,
+
     pub backend: String,
     pub abi: Abi,
 

tooling/nargo/src/ops/test.rs

@@ -20,7 +20,7 @@ pub fn run_test<B: BlackBoxFunctionSolver>(
     show_output: bool,
     config: &CompileOptions,
 ) -> TestStatus {
-    let program = compile_no_check(context, config, test_function.get_id());
+    let program = compile_no_check(context, config, test_function.get_id(), None);
     match program {
         Ok(program) => {
             // Run the backend to ensure the PWG evaluates functions like std::hash::pedersen,

tooling/nargo/src/workspace.rs

@@ -25,7 +25,7 @@ pub struct Workspace {
 impl Workspace {
     pub fn package_build_path(&self, package: &Package) -> PathBuf {
         let name: String = package.name.clone().into();
-        self.target_directory_path().join(name)
+        self.target_directory_path().join(name).with_extension("json")
     }
 
     pub fn contracts_directory_path(&self, package: &Package) -> PathBuf {