checkpoint in reconstruction

src/bin/ngrun.rs

@@ -0,0 +1,74 @@
+use clap::Parser;
+use codespan_reporting::files::SimpleFiles;
+use ngr::eval::Value;
+use ngr::syntax;
+use ngr::type_infer::TypeInferenceResult;
+use pretty::termcolor::StandardStream;
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct CommandLineArguments {
+    /// Which interpreter to use: syntax, ir, or jit
+    #[arg(value_enum)]
+    interpreter: Interpreter,
+
+    /// The file to parse
+    file: String,
+}
+
+#[allow(clippy::upper_case_acronyms)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
+enum Interpreter {
+    /// Run the syntax-level interpreter
+    Syntax,
+    /// Run the IR-level interpreter
+    IR,
+    /// Run the JIT backend
+    JIT,
+}
+
+fn print_result<E>(result: (Value<E>, String)) {
+    println!("{}", result.1);
+    println!("RESULT: {}", result.0);
+}
+
+fn main() -> Result<(), anyhow::Error> {
+    let cli = CommandLineArguments::parse();
+    let mut file_database = SimpleFiles::new();
+    let mut console = StandardStream::stdout(pretty::termcolor::ColorChoice::Auto);
+    let console_options = codespan_reporting::term::Config::default();
+    let syntax = syntax::Program::parse_file(&mut file_database, cli.file.as_ref())?;
+    let mut emit = |x| {
+        let _ = codespan_reporting::term::emit(&mut console, &console_options, &file_database, &x);
+    };
+
+    if cli.interpreter == Interpreter::Syntax {
+        print_result(syntax.eval()?);
+        return Ok(());
+    }
+
+    let ir = match syntax.type_infer() {
+        TypeInferenceResult::Success { result, warnings } => {
+            for warning in warnings {
+                emit(warning.into());
+            }
+            result
+        }
+        TypeInferenceResult::Failure { errors, warnings } => {
+            for warning in warnings {
+                emit(warning.into());
+            }
+            for error in errors {
+                emit(error.into());
+            }
+            return Err(anyhow::anyhow!("failed to infer program types"));
+        }
+    };
+
+    if cli.interpreter == Interpreter::IR {
+        print_result(ir.eval()?);
+        return Ok(());
+    }
+
+    unimplemented!();
+}