Add a command to evaluate a single expression, using a fake module to do so (for includes).

When we can include things in-scope in the future, this can be changed to an anonymous expression.

Author: Ivorforce

src/cli.rs

@@ -3,6 +3,7 @@ use std::process::ExitCode;
 use crate::cli::logging::dump_failure;
 
 pub mod run;
+pub mod expression;
 pub mod check;
 pub mod transpile;
 pub mod logging;
@@ -14,6 +15,7 @@ pub fn make_command() -> Command {
         .arg_required_else_help(true)
         .allow_external_subcommands(true)
         .subcommand(run::make_command())
+        .subcommand(expression::make_command())
         .subcommand(check::make_command())
         .subcommand(transpile::make_command())
 }
@@ -23,6 +25,7 @@ pub fn run_command() -> ExitCode {
 
     let result = match matches.subcommand() {
         Some(("run", sub_matches)) => run::run(sub_matches),
+        Some(("expression", sub_matches)) => expression::run(sub_matches),
         Some(("check", sub_matches)) => check::run(sub_matches),
         Some(("transpile", sub_matches)) => transpile::run(sub_matches),
         _ => panic!("Unsupported action."),

src/cli/expression.rs

@@ -0,0 +1,32 @@
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+use clap::{arg, ArgMatches, Command};
+
+use crate::error::RResult;
+use crate::{interpreter, parser};
+use crate::interpreter::runtime::Runtime;
+use crate::program::functions::FunctionInterface;
+use crate::program::module::{module_name, ModuleName};
+use crate::program::types::TypeProto;
+
+pub fn make_command() -> Command {
+    Command::new("expression")
+        .about("Run an expression using the interpreter.")
+        .arg_required_else_help(true)
+        .arg(arg!(<EXPRESSION> "expression to run").value_parser(clap::value_parser!(String)))
+}
+
+pub fn run(args: &ArgMatches) -> RResult<ExitCode> {
+    let expression = args.get_one::<String>("EXPRESSION").unwrap();
+    let full_expression = format!("use!(module!(\"common\")); def main! :: write_line({});", expression);
+
+    let mut runtime = Runtime::new()?;
+    runtime.add_common_repository();
+
+    let module = runtime.load_text_as_module(&full_expression, vec!["dynamic".to_string()])?;
+
+    interpreter::run::main(&module, &mut runtime)?;
+
+    Ok(ExitCode::SUCCESS)
+}