test(tvix/cli): Make the REPL testable r/8353

Juggle around the internals of the tvix-cli crate so that we expose the
Repl as a public type with a `send` method, that sends a string to the
repl and *captures all output* so that it can be subsequently asserted
on in tests. Then, demonstrate that this works with a single (for now)
REPL test using expect-test to assert on the output of a single command
sent to the REPL.

As the REPL gets more complicated, this will allow us to make tests that
cover that complex behavior.

Change-Id: I88175bd72d8760c79faade95ebb1d956f08a7b83
Reviewed-on: https://cl.tvl.fyi/c/depot/+/11958
Autosubmit: aspen <root@gws.fyi>
Tested-by: BuildkiteCI
Reviewed-by: flokli <flokli@flokli.de>

4 files changed, 436 insertions, 346 deletions

diff --git a/tvix/cli/src/args.rs b/tvix/cli/src/args.rs
new file mode 100644
index 000000000000..ebb3c0dc107e
--- /dev/null
+++ b/tvix/cli/src/args.rs
@@ -0,0 +1,72 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use tracing::Level;
+
+#[derive(Parser, Clone)]
+pub struct Args {
+    /// A global log level to use when printing logs.
+    /// It's also possible to set `RUST_LOG` according to
+    /// `tracing_subscriber::filter::EnvFilter`, which will always have
+    /// priority.
+    #[arg(long, default_value_t=Level::INFO)]
+    pub log_level: Level,
+
+    /// Path to a script to evaluate
+    pub script: Option<PathBuf>,
+
+    #[clap(long, short = 'E')]
+    pub expr: Option<String>,
+
+    /// Dump the raw AST to stdout before interpreting
+    #[clap(long, env = "TVIX_DISPLAY_AST")]
+    pub display_ast: bool,
+
+    /// Dump the bytecode to stdout before evaluating
+    #[clap(long, env = "TVIX_DUMP_BYTECODE")]
+    pub dump_bytecode: bool,
+
+    /// Trace the runtime of the VM
+    #[clap(long, env = "TVIX_TRACE_RUNTIME")]
+    pub trace_runtime: bool,
+
+    /// Capture the time (relative to the start time of evaluation) of all events traced with
+    /// `--trace-runtime`
+    #[clap(long, env = "TVIX_TRACE_RUNTIME_TIMING", requires("trace_runtime"))]
+    pub trace_runtime_timing: bool,
+
+    /// Only compile, but do not execute code. This will make Tvix act
+    /// sort of like a linter.
+    #[clap(long)]
+    pub compile_only: bool,
+
+    /// Don't print warnings.
+    #[clap(long)]
+    pub no_warnings: bool,
+
+    /// A colon-separated list of directories to use to resolve `<...>`-style paths
+    #[clap(long, short = 'I', env = "NIX_PATH")]
+    pub nix_search_path: Option<String>,
+
+    /// Print "raw" (unquoted) output.
+    #[clap(long)]
+    pub raw: bool,
+
+    /// Strictly evaluate values, traversing them and forcing e.g.
+    /// elements of lists and attribute sets before printing the
+    /// return value.
+    #[clap(long)]
+    pub strict: bool,
+
+    #[arg(long, env, default_value = "memory://")]
+    pub blob_service_addr: String,
+
+    #[arg(long, env, default_value = "memory://")]
+    pub directory_service_addr: String,
+
+    #[arg(long, env, default_value = "memory://")]
+    pub path_info_service_addr: String,
+
+    #[arg(long, env, default_value = "dummy://")]
+    pub build_service_addr: String,
+}
diff --git a/tvix/cli/src/lib.rs b/tvix/cli/src/lib.rs
new file mode 100644
index 000000000000..008593c5d84f
--- /dev/null
+++ b/tvix/cli/src/lib.rs
@@ -0,0 +1,224 @@
+use std::{collections::HashMap, path::PathBuf, rc::Rc};
+
+use smol_str::SmolStr;
+use std::fmt::Write;
+use tracing::{instrument, Span};
+use tracing_indicatif::span_ext::IndicatifSpanExt;
+use tvix_build::buildservice;
+use tvix_eval::{
+    builtins::impure_builtins,
+    observer::{DisassemblingObserver, TracingObserver},
+    ErrorKind, EvalIO, Value,
+};
+use tvix_glue::{
+    builtins::{add_derivation_builtins, add_fetcher_builtins, add_import_builtins},
+    configure_nix_path,
+    tvix_io::TvixIO,
+    tvix_store_io::TvixStoreIO,
+};
+
+pub mod args;
+pub mod assignment;
+pub mod repl;
+
+pub use args::Args;
+pub use repl::Repl;
+
+pub fn init_io_handle(tokio_runtime: &tokio::runtime::Runtime, args: &Args) -> Rc<TvixStoreIO> {
+    let (blob_service, directory_service, path_info_service, nar_calculation_service) =
+        tokio_runtime
+            .block_on({
+                let blob_service_addr = args.blob_service_addr.clone();
+                let directory_service_addr = args.directory_service_addr.clone();
+                let path_info_service_addr = args.path_info_service_addr.clone();
+                async move {
+                    tvix_store::utils::construct_services(
+                        blob_service_addr,
+                        directory_service_addr,
+                        path_info_service_addr,
+                    )
+                    .await
+                }
+            })
+            .expect("unable to setup {blob|directory|pathinfo}service before interpreter setup");
+
+    let build_service = tokio_runtime
+        .block_on({
+            let blob_service = blob_service.clone();
+            let directory_service = directory_service.clone();
+            async move {
+                buildservice::from_addr(
+                    &args.build_service_addr,
+                    blob_service.clone(),
+                    directory_service.clone(),
+                )
+                .await
+            }
+        })
+        .expect("unable to setup buildservice before interpreter setup");
+
+    Rc::new(TvixStoreIO::new(
+        blob_service.clone(),
+        directory_service.clone(),
+        path_info_service.into(),
+        nar_calculation_service.into(),
+        build_service.into(),
+        tokio_runtime.handle().clone(),
+    ))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum AllowIncomplete {
+    Allow,
+    #[default]
+    RequireComplete,
+}
+
+impl AllowIncomplete {
+    fn allow(&self) -> bool {
+        matches!(self, Self::Allow)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct IncompleteInput;
+
+/// Interprets the given code snippet, printing out warnings and errors and returning the result
+pub fn evaluate(
+    tvix_store_io: Rc<TvixStoreIO>,
+    code: &str,
+    path: Option<PathBuf>,
+    args: &Args,
+    allow_incomplete: AllowIncomplete,
+    env: Option<&HashMap<SmolStr, Value>>,
+) -> Result<Option<Value>, IncompleteInput> {
+    let span = Span::current();
+    span.pb_start();
+    span.pb_set_style(&tvix_tracing::PB_SPINNER_STYLE);
+    span.pb_set_message("Setting up evaluator…");
+
+    let mut eval_builder = tvix_eval::Evaluation::builder(Box::new(TvixIO::new(
+        tvix_store_io.clone() as Rc<dyn EvalIO>,
+    )) as Box<dyn EvalIO>)
+    .enable_import()
+    .with_strict(args.strict)
+    .add_builtins(impure_builtins())
+    .env(env);
+
+    eval_builder = add_derivation_builtins(eval_builder, Rc::clone(&tvix_store_io));
+    eval_builder = add_fetcher_builtins(eval_builder, Rc::clone(&tvix_store_io));
+    eval_builder = add_import_builtins(eval_builder, tvix_store_io);
+    eval_builder = configure_nix_path(eval_builder, &args.nix_search_path);
+
+    let source_map = eval_builder.source_map().clone();
+    let result = {
+        let mut compiler_observer =
+            DisassemblingObserver::new(source_map.clone(), std::io::stderr());
+        if args.dump_bytecode {
+            eval_builder.set_compiler_observer(Some(&mut compiler_observer));
+        }
+
+        let mut runtime_observer = TracingObserver::new(std::io::stderr());
+        if args.trace_runtime {
+            if args.trace_runtime_timing {
+                runtime_observer.enable_timing()
+            }
+            eval_builder.set_runtime_observer(Some(&mut runtime_observer));
+        }
+
+        span.pb_set_message("Evaluating…");
+
+        let eval = eval_builder.build();
+        eval.evaluate(code, path)
+    };
+
+    if allow_incomplete.allow()
+        && result.errors.iter().any(|err| {
+            matches!(
+                &err.kind,
+                ErrorKind::ParseErrors(pes)
+                    if pes.iter().any(|pe| matches!(pe, rnix::parser::ParseError::UnexpectedEOF))
+            )
+        })
+    {
+        return Err(IncompleteInput);
+    }
+
+    if args.display_ast {
+        if let Some(ref expr) = result.expr {
+            eprintln!("AST: {}", tvix_eval::pretty_print_expr(expr));
+        }
+    }
+
+    for error in &result.errors {
+        error.fancy_format_stderr();
+    }
+
+    if !args.no_warnings {
+        for warning in &result.warnings {
+            warning.fancy_format_stderr(&source_map);
+        }
+    }
+
+    Ok(result.value)
+}
+
+pub struct InterpretResult {
+    output: String,
+    success: bool,
+}
+
+impl InterpretResult {
+    pub fn empty_success() -> Self {
+        Self {
+            output: String::new(),
+            success: true,
+        }
+    }
+
+    pub fn finalize(self) -> bool {
+        print!("{}", self.output);
+        self.success
+    }
+
+    pub fn output(&self) -> &str {
+        &self.output
+    }
+
+    pub fn success(&self) -> bool {
+        self.success
+    }
+}
+
+/// Interprets the given code snippet, printing out warnings, errors
+/// and the result itself. The return value indicates whether
+/// evaluation succeeded.
+#[instrument(skip_all, fields(indicatif.pb_show=1))]
+pub fn interpret(
+    tvix_store_io: Rc<TvixStoreIO>,
+    code: &str,
+    path: Option<PathBuf>,
+    args: &Args,
+    explain: bool,
+    allow_incomplete: AllowIncomplete,
+    env: Option<&HashMap<SmolStr, Value>>,
+) -> Result<InterpretResult, IncompleteInput> {
+    let mut output = String::new();
+    let result = evaluate(tvix_store_io, code, path, args, allow_incomplete, env)?;
+
+    if let Some(value) = result.as_ref() {
+        if explain {
+            writeln!(&mut output, "=> {}", value.explain()).unwrap();
+        } else if args.raw {
+            writeln!(&mut output, "{}", value.to_contextful_str().unwrap()).unwrap();
+        } else {
+            writeln!(&mut output, "=> {} :: {}", value, value.type_of()).unwrap();
+        }
+    }
+
+    // inform the caller about any errors
+    Ok(InterpretResult {
+        output,
+        success: result.is_some(),
+    })
+}
diff --git a/tvix/cli/src/main.rs b/tvix/cli/src/main.rs
index 2f7dc58a23aa..0bd3be37eeb2 100644
--- a/tvix/cli/src/main.rs
+++ b/tvix/cli/src/main.rs
@@ -1,23 +1,11 @@
-mod assignment;
-mod repl;
-
 use clap::Parser;
-use repl::Repl;
-use smol_str::SmolStr;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::{fs, path::PathBuf};
-use tracing::{instrument, Level, Span};
-use tracing_indicatif::span_ext::IndicatifSpanExt;
-use tvix_build::buildservice;
-use tvix_eval::builtins::impure_builtins;
-use tvix_eval::observer::{DisassemblingObserver, TracingObserver};
-use tvix_eval::{ErrorKind, EvalIO, Value};
-use tvix_glue::builtins::add_fetcher_builtins;
-use tvix_glue::builtins::add_import_builtins;
-use tvix_glue::tvix_io::TvixIO;
+use tvix_cli::args::Args;
+use tvix_cli::repl::Repl;
+use tvix_cli::{init_io_handle, interpret, AllowIncomplete};
+use tvix_eval::observer::DisassemblingObserver;
 use tvix_glue::tvix_store_io::TvixStoreIO;
-use tvix_glue::{builtins::add_derivation_builtins, configure_nix_path};
 
 #[cfg(not(target_env = "msvc"))]
 use tikv_jemallocator::Jemalloc;
@@ -26,240 +14,6 @@ use tikv_jemallocator::Jemalloc;
 #[global_allocator]
 static GLOBAL: Jemalloc = Jemalloc;
 
-#[derive(Parser, Clone)]
-struct Args {
-    /// A global log level to use when printing logs.
-    /// It's also possible to set `RUST_LOG` according to
-    /// `tracing_subscriber::filter::EnvFilter`, which will always have
-    /// priority.
-    #[arg(long, default_value_t=Level::INFO)]
-    log_level: Level,
-
-    /// Path to a script to evaluate
-    script: Option<PathBuf>,
-
-    #[clap(long, short = 'E')]
-    expr: Option<String>,
-
-    /// Dump the raw AST to stdout before interpreting
-    #[clap(long, env = "TVIX_DISPLAY_AST")]
-    display_ast: bool,
-
-    /// Dump the bytecode to stdout before evaluating
-    #[clap(long, env = "TVIX_DUMP_BYTECODE")]
-    dump_bytecode: bool,
-
-    /// Trace the runtime of the VM
-    #[clap(long, env = "TVIX_TRACE_RUNTIME")]
-    trace_runtime: bool,
-
-    /// Capture the time (relative to the start time of evaluation) of all events traced with
-    /// `--trace-runtime`
-    #[clap(long, env = "TVIX_TRACE_RUNTIME_TIMING", requires("trace_runtime"))]
-    trace_runtime_timing: bool,
-
-    /// Only compile, but do not execute code. This will make Tvix act
-    /// sort of like a linter.
-    #[clap(long)]
-    compile_only: bool,
-
-    /// Don't print warnings.
-    #[clap(long)]
-    no_warnings: bool,
-
-    /// A colon-separated list of directories to use to resolve `<...>`-style paths
-    #[clap(long, short = 'I', env = "NIX_PATH")]
-    nix_search_path: Option<String>,
-
-    /// Print "raw" (unquoted) output.
-    #[clap(long)]
-    raw: bool,
-
-    /// Strictly evaluate values, traversing them and forcing e.g.
-    /// elements of lists and attribute sets before printing the
-    /// return value.
-    #[clap(long)]
-    strict: bool,
-
-    #[arg(long, env, default_value = "memory://")]
-    blob_service_addr: String,
-
-    #[arg(long, env, default_value = "memory://")]
-    directory_service_addr: String,
-
-    #[arg(long, env, default_value = "memory://")]
-    path_info_service_addr: String,
-
-    #[arg(long, env, default_value = "dummy://")]
-    build_service_addr: String,
-}
-
-fn init_io_handle(tokio_runtime: &tokio::runtime::Runtime, args: &Args) -> Rc<TvixStoreIO> {
-    let (blob_service, directory_service, path_info_service, nar_calculation_service) =
-        tokio_runtime
-            .block_on({
-                let blob_service_addr = args.blob_service_addr.clone();
-                let directory_service_addr = args.directory_service_addr.clone();
-                let path_info_service_addr = args.path_info_service_addr.clone();
-                async move {
-                    tvix_store::utils::construct_services(
-                        blob_service_addr,
-                        directory_service_addr,
-                        path_info_service_addr,
-                    )
-                    .await
-                }
-            })
-            .expect("unable to setup {blob|directory|pathinfo}service before interpreter setup");
-
-    let build_service = tokio_runtime
-        .block_on({
-            let blob_service = blob_service.clone();
-            let directory_service = directory_service.clone();
-            async move {
-                buildservice::from_addr(
-                    &args.build_service_addr,
-                    blob_service.clone(),
-                    directory_service.clone(),
-                )
-                .await
-            }
-        })
-        .expect("unable to setup buildservice before interpreter setup");
-
-    Rc::new(TvixStoreIO::new(
-        blob_service.clone(),
-        directory_service.clone(),
-        path_info_service.into(),
-        nar_calculation_service.into(),
-        build_service.into(),
-        tokio_runtime.handle().clone(),
-    ))
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-enum AllowIncomplete {
-    Allow,
-    #[default]
-    RequireComplete,
-}
-
-impl AllowIncomplete {
-    fn allow(&self) -> bool {
-        matches!(self, Self::Allow)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-struct IncompleteInput;
-
-/// Interprets the given code snippet, printing out warnings and errors and returning the result
-fn evaluate(
-    tvix_store_io: Rc<TvixStoreIO>,
-    code: &str,
-    path: Option<PathBuf>,
-    args: &Args,
-    allow_incomplete: AllowIncomplete,
-    env: Option<&HashMap<SmolStr, Value>>,
-) -> Result<Option<Value>, IncompleteInput> {
-    let span = Span::current();
-    span.pb_start();
-    span.pb_set_style(&tvix_tracing::PB_SPINNER_STYLE);
-    span.pb_set_message("Setting up evaluator…");
-
-    let mut eval_builder = tvix_eval::Evaluation::builder(Box::new(TvixIO::new(
-        tvix_store_io.clone() as Rc<dyn EvalIO>,
-    )) as Box<dyn EvalIO>)
-    .enable_import()
-    .with_strict(args.strict)
-    .add_builtins(impure_builtins())
-    .env(env);
-
-    eval_builder = add_derivation_builtins(eval_builder, Rc::clone(&tvix_store_io));
-    eval_builder = add_fetcher_builtins(eval_builder, Rc::clone(&tvix_store_io));
-    eval_builder = add_import_builtins(eval_builder, tvix_store_io);
-    eval_builder = configure_nix_path(eval_builder, &args.nix_search_path);
-
-    let source_map = eval_builder.source_map().clone();
-    let result = {
-        let mut compiler_observer =
-            DisassemblingObserver::new(source_map.clone(), std::io::stderr());
-        if args.dump_bytecode {
-            eval_builder.set_compiler_observer(Some(&mut compiler_observer));
-        }
-
-        let mut runtime_observer = TracingObserver::new(std::io::stderr());
-        if args.trace_runtime {
-            if args.trace_runtime_timing {
-                runtime_observer.enable_timing()
-            }
-            eval_builder.set_runtime_observer(Some(&mut runtime_observer));
-        }
-
-        span.pb_set_message("Evaluating…");
-
-        let eval = eval_builder.build();
-        eval.evaluate(code, path)
-    };
-
-    if allow_incomplete.allow()
-        && result.errors.iter().any(|err| {
-            matches!(
-                &err.kind,
-                ErrorKind::ParseErrors(pes)
-                    if pes.iter().any(|pe| matches!(pe, rnix::parser::ParseError::UnexpectedEOF))
-            )
-        })
-    {
-        return Err(IncompleteInput);
-    }
-
-    if args.display_ast {
-        if let Some(ref expr) = result.expr {
-            eprintln!("AST: {}", tvix_eval::pretty_print_expr(expr));
-        }
-    }
-
-    for error in &result.errors {
-        error.fancy_format_stderr();
-    }
-
-    if !args.no_warnings {
-        for warning in &result.warnings {
-            warning.fancy_format_stderr(&source_map);
-        }
-    }
-
-    Ok(result.value)
-}
-
-/// Interprets the given code snippet, printing out warnings, errors
-/// and the result itself. The return value indicates whether
-/// evaluation succeeded.
-#[instrument(skip_all, fields(indicatif.pb_show=1))]
-fn interpret(
-    tvix_store_io: Rc<TvixStoreIO>,
-    code: &str,
-    path: Option<PathBuf>,
-    args: &Args,
-    explain: bool,
-    allow_incomplete: AllowIncomplete,
-    env: Option<&HashMap<SmolStr, Value>>,
-) -> Result<bool, IncompleteInput> {
-    let result = evaluate(tvix_store_io, code, path, args, allow_incomplete, env)?;
-
-    if let Some(value) = result.as_ref() {
-        if explain {
-            println!("=> {}", value.explain());
-        } else {
-            println_result(value, args.raw);
-        }
-    }
-
-    // inform the caller about any errors
-    Ok(result.is_some())
-}
-
 /// Interpret the given code snippet, but only run the Tvix compiler
 /// on it and return errors and warnings.
 fn lint(code: &str, path: Option<PathBuf>, args: &Args) -> bool {
@@ -323,12 +77,13 @@ fn main() {
             None, // TODO(aspen): Pass in --arg/--argstr here
         )
         .unwrap()
+        .finalize()
         {
             std::process::exit(1);
         }
     } else {
-        let mut repl = Repl::new();
-        repl.run(io_handle, &args)
+        let mut repl = Repl::new(io_handle, &args);
+        repl.run()
     }
 }
 
@@ -351,17 +106,10 @@ fn run_file(io_handle: Rc<TvixStoreIO>, mut path: PathBuf, args: &Args) {
             None,
         )
         .unwrap()
+        .finalize()
     };
 
     if !success {
         std::process::exit(1);
     }
 }
-
-fn println_result(result: &Value, raw: bool) {
-    if raw {
-        println!("{}", result.to_contextful_str().unwrap())
-    } else {
-        println!("=> {} :: {}", result, result.type_of())
-    }
-}
diff --git a/tvix/cli/src/repl.rs b/tvix/cli/src/repl.rs
index 758874016326..5098fbaeedc3 100644
--- a/tvix/cli/src/repl.rs
+++ b/tvix/cli/src/repl.rs
@@ -6,8 +6,10 @@ use smol_str::SmolStr;
 use tvix_eval::Value;
 use tvix_glue::tvix_store_io::TvixStoreIO;
 
-use crate::evaluate;
-use crate::{assignment::Assignment, interpret, AllowIncomplete, Args, IncompleteInput};
+use crate::{
+    assignment::Assignment, evaluate, interpret, AllowIncomplete, Args, IncompleteInput,
+    InterpretResult,
+};
 
 fn state_dir() -> Option<PathBuf> {
     let mut path = dirs::data_dir();
@@ -18,7 +20,7 @@ fn state_dir() -> Option<PathBuf> {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ReplCommand<'a> {
+pub(crate) enum ReplCommand<'a> {
     Expr(&'a str),
     Assign(Assignment<'a>),
     Explain(&'a str),
@@ -65,27 +67,47 @@ The following commands are supported:
     }
 }
 
-#[derive(Debug)]
-pub struct Repl {
+pub struct CommandResult {
+    output: String,
+    continue_: bool,
+}
+
+impl CommandResult {
+    pub fn finalize(self) -> bool {
+        print!("{}", self.output);
+        self.continue_
+    }
+
+    pub fn output(&self) -> &str {
+        &self.output
+    }
+}
+
+pub struct Repl<'a> {
     /// In-progress multiline input, when the input so far doesn't parse as a complete expression
     multiline_input: Option<String>,
     rl: Editor<()>,
     /// Local variables defined at the top-level in the repl
     env: HashMap<SmolStr, Value>,
+
+    io_handle: Rc<TvixStoreIO>,
+    args: &'a Args,
 }
 
-impl Repl {
-    pub fn new() -> Self {
+impl<'a> Repl<'a> {
+    pub fn new(io_handle: Rc<TvixStoreIO>, args: &'a Args) -> Self {
         let rl = Editor::<()>::new().expect("should be able to launch rustyline");
         Self {
             multiline_input: None,
             rl,
             env: HashMap::new(),
+            io_handle,
+            args,
         }
     }
 
-    pub fn run(&mut self, io_handle: Rc<TvixStoreIO>, args: &Args) {
-        if args.compile_only {
+    pub fn run(&mut self) {
+        if self.args.compile_only {
             eprintln!("warning: `--compile-only` has no effect on REPL usage!");
         }
 
@@ -112,83 +134,8 @@ impl Repl {
             let readline = self.rl.readline(prompt);
             match readline {
                 Ok(line) => {
-                    if line.is_empty() {
-                        continue;
-                    }
-
-                    let input = if let Some(mi) = &mut self.multiline_input {
-                        mi.push('\n');
-                        mi.push_str(&line);
-                        mi
-                    } else {
-                        &line
-                    };
-
-                    let res = match ReplCommand::parse(input) {
-                        ReplCommand::Quit => break,
-                        ReplCommand::Help => {
-                            println!("{}", ReplCommand::HELP);
-                            Ok(false)
-                        }
-                        ReplCommand::Expr(input) => interpret(
-                            Rc::clone(&io_handle),
-                            input,
-                            None,
-                            args,
-                            false,
-                            AllowIncomplete::Allow,
-                            Some(&self.env),
-                        ),
-                        ReplCommand::Assign(Assignment { ident, value }) => {
-                            match evaluate(
-                                Rc::clone(&io_handle),
-                                &value.to_string(), /* FIXME: don't re-parse */
-                                None,
-                                args,
-                                AllowIncomplete::Allow,
-                                Some(&self.env),
-                            ) {
-                                Ok(Some(value)) => {
-                                    self.env.insert(ident.into(), value);
-                                    Ok(true)
-                                }
-                                Ok(None) => Ok(true),
-                                Err(incomplete) => Err(incomplete),
-                            }
-                        }
-                        ReplCommand::Explain(input) => interpret(
-                            Rc::clone(&io_handle),
-                            input,
-                            None,
-                            args,
-                            true,
-                            AllowIncomplete::Allow,
-                            Some(&self.env),
-                        ),
-                        ReplCommand::Print(input) => interpret(
-                            Rc::clone(&io_handle),
-                            input,
-                            None,
-                            &Args {
-                                strict: true,
-                                ..(args.clone())
-                            },
-                            false,
-                            AllowIncomplete::Allow,
-                            Some(&self.env),
-                        ),
-                    };
-
-                    match res {
-                        Ok(_) => {
-                            self.rl.add_history_entry(input);
-                            self.multiline_input = None;
-                        }
-                        Err(IncompleteInput) => {
-                            if self.multiline_input.is_none() {
-                                self.multiline_input = Some(line);
-                            }
-                        }
+                    if !self.send(line).finalize() {
+                        break;
                     }
                 }
                 Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => break,
@@ -204,4 +151,103 @@ impl Repl {
             self.rl.save_history(&path).unwrap();
         }
     }
+
+    /// Send a line of user input to the REPL. Returns a result indicating the output to show to the
+    /// user, and whether or not to continue
+    pub fn send(&mut self, line: String) -> CommandResult {
+        if line.is_empty() {
+            return CommandResult {
+                output: String::new(),
+                continue_: true,
+            };
+        }
+
+        let input = if let Some(mi) = &mut self.multiline_input {
+            mi.push('\n');
+            mi.push_str(&line);
+            mi
+        } else {
+            &line
+        };
+
+        let res = match ReplCommand::parse(input) {
+            ReplCommand::Quit => {
+                return CommandResult {
+                    output: String::new(),
+                    continue_: true,
+                };
+            }
+            ReplCommand::Help => {
+                println!("{}", ReplCommand::HELP);
+                Ok(InterpretResult::empty_success())
+            }
+            ReplCommand::Expr(input) => interpret(
+                Rc::clone(&self.io_handle),
+                input,
+                None,
+                self.args,
+                false,
+                AllowIncomplete::Allow,
+                Some(&self.env),
+            ),
+            ReplCommand::Assign(Assignment { ident, value }) => {
+                match evaluate(
+                    Rc::clone(&self.io_handle),
+                    &value.to_string(), /* FIXME: don't re-parse */
+                    None,
+                    self.args,
+                    AllowIncomplete::Allow,
+                    Some(&self.env),
+                ) {
+                    Ok(Some(value)) => {
+                        self.env.insert(ident.into(), value);
+                        Ok(InterpretResult::empty_success())
+                    }
+                    Ok(None) => Ok(InterpretResult::empty_success()),
+                    Err(incomplete) => Err(incomplete),
+                }
+            }
+            ReplCommand::Explain(input) => interpret(
+                Rc::clone(&self.io_handle),
+                input,
+                None,
+                self.args,
+                true,
+                AllowIncomplete::Allow,
+                Some(&self.env),
+            ),
+            ReplCommand::Print(input) => interpret(
+                Rc::clone(&self.io_handle),
+                input,
+                None,
+                &Args {
+                    strict: true,
+                    ..(self.args.clone())
+                },
+                false,
+                AllowIncomplete::Allow,
+                Some(&self.env),
+            ),
+        };
+
+        match res {
+            Ok(InterpretResult { output, .. }) => {
+                self.rl.add_history_entry(input);
+                self.multiline_input = None;
+                CommandResult {
+                    output,
+                    continue_: true,
+                }
+            }
+            Err(IncompleteInput) => {
+                if self.multiline_input.is_none() {
+                    self.multiline_input = Some(line);
+                }
+                CommandResult {
+                    output: String::new(),
+                    continue_: true,
+                }
+            }
+        }
+    }
 }