supernova finish constaints done, add workaround to collect meta info…

… from asm source

ast/src/asm_analysis/mod.rs

@@ -42,7 +42,7 @@ pub struct DegreeStatement {
     pub degree: BigUint,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum FunctionStatement<T> {
     Assignment(AssignmentStatement<T>),
     Instruction(InstructionStatement<T>),
@@ -74,28 +74,28 @@ impl<T> From<DebugDirective> for FunctionStatement<T> {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct AssignmentStatement<T> {
     pub start: usize,
     pub lhs: Vec<String>,
     pub using_reg: Option<String>,
     pub rhs: Box<Expression<T>>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct InstructionStatement<T> {
     pub start: usize,
     pub instruction: String,
     pub inputs: Vec<Expression<T>>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct LabelStatement {
     pub start: usize,
     pub name: String,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct DebugDirective {
     pub start: usize,
     pub directive: crate::parsed::asm::DebugDirective,
@@ -130,7 +130,7 @@ impl<T> Machine<T> {
     }
 }
 
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct Rom<T> {
     pub statements: Vec<FunctionStatement<T>>,
     pub batches: Option<Vec<BatchMetadata>>,

backend/src/lib.rs

@@ -1,4 +1,4 @@
-use ast::analyzed::Analyzed;
+use ast::{analyzed::Analyzed, asm_analysis::Machine};
 use number::FieldElement;
 use std::io;
 use strum::{Display, EnumString, EnumVariantNames};
@@ -107,13 +107,20 @@ impl ProverAggregationWithParams for Halo2AggregationBackend {
 }
 
 #[cfg(feature = "nova")]
-impl ProverWithoutParams for NovaBackend {
-    fn prove<T: FieldElement>(
+// TODO implement ProverWithoutParams, and remove dependent on main_machine
+impl NovaBackend {
+    pub fn prove<T: FieldElement>(
         pil: &Analyzed<T>,
+        main_machine: &Machine<T>,
         fixed: Vec<(&str, Vec<T>)>,
         witness: Vec<(&str, Vec<T>)>,
     ) -> Option<Proof> {
-        Some(nova::prove_ast_read_params(pil, fixed, witness));
+        Some(nova::prove_ast_read_params(
+            pil,
+            main_machine,
+            fixed,
+            witness,
+        ));
         Some(vec![])
     }
 }

compiler/src/lib.rs

@@ -14,7 +14,8 @@ use json::JsonValue;
 pub mod util;
 mod verify;
 
-use analysis::analyze;
+// TODO should analyze be `pub`?
+pub use analysis::analyze;
 pub use backend::{Backend, Proof};
 use number::write_polys_file;
 use pil_analyzer::json_exporter;

number/src/traits.rs

@@ -1,6 +1,5 @@
 use std::{fmt, hash::Hash, ops::*};
 
-use ark_ff::PrimeField;
 use num_traits::{One, Zero};
 
 use crate::{AbstractNumberType, DegreeType};

powdr_cli/src/main.rs

@@ -3,7 +3,7 @@
 mod util;
 
 use clap::{Parser, Subcommand};
-use compiler::{compile_pil_or_asm, Backend};
+use compiler::{analyze, compile_pil_or_asm, Backend};
 use env_logger::{Builder, Target};
 use log::LevelFilter;
 use number::{Bn254Field, FieldElement, GoldilocksField};
@@ -188,6 +188,9 @@ enum Commands {
         /// Input PIL file
         file: String,
 
+        /// TODO retrive asm info from PIL
+        asm_file: String,
+
         /// Directory to find the committed and fixed values
         #[arg(short, long)]
         #[arg(default_value_t = String::from("."))]
@@ -372,18 +375,41 @@ fn run_command(command: Commands) {
         #[cfg(feature = "nova")]
         Commands::ProveNova {
             file,
+            asm_file,
             dir,
             params: _,
         } => {
             let pil = Path::new(&file);
+            let contents = fs::read_to_string(asm_file.clone()).unwrap();
+
+            let parsed = parser::parse_asm::<Bn254Field>(Some(&asm_file[..]), &contents[..])
+                .unwrap_or_else(|err| {
+                    eprintln!("Error parsing .asm file:");
+                    err.output_to_stderr();
+                    panic!();
+                });
+            let analysed_asm = analyze(parsed).unwrap();
+
+            // retrieve instance of the Main state machine
+            let main = match analysed_asm.machines.len() {
+                // if there is a single machine, treat it as main
+                1 => analysed_asm.machines.values().next().unwrap().clone(),
+                // otherwise, find the machine called "Main"
+                _ => analysed_asm
+                    .machines
+                    .get("Main")
+                    .expect("couldn't find a Main state machine")
+                    .clone(),
+            };
+
             let dir = Path::new(&dir);
 
             let pil = compiler::analyze_pil::<Bn254Field>(pil);
             let fixed = compiler::util::read_fixed(&pil, dir);
             let witness = compiler::util::read_witness(&pil, dir);
 
             // let params = fs::File::open(dir.join(params.unwrap())).unwrap();
-            NovaBackend::prove(&pil, fixed.0, witness.0);
+            NovaBackend::prove(&pil, &main, fixed.0, witness.0);
 
             // TODO: this probably should be abstracted alway in a common backends API,
             // // maybe a function "get_file_extension()".