orchid/orcx/src/main.rs

pub mod parse_folder;

use std::cell::RefCell;
use std::fs::File;
use std::io::{Read, Write};
use std::mem;
use std::process::{Command, ExitCode};
use std::rc::Rc;

use async_fn_stream::try_stream;
use camino::Utf8PathBuf;
use clap::{Parser, Subcommand};
use futures::{Stream, TryStreamExt, io};
use itertools::Itertools;
use orchid_base::error::Reporter;
use orchid_base::format::{FmtCtxImpl, Format, take_first};
use orchid_base::location::SrcRange;
use orchid_base::logging::{LogStrategy, Logger};
use orchid_base::name::{NameLike, VPath};
use orchid_base::parse::{Import, Snippet};
use orchid_base::sym;
use orchid_base::tree::{Token, ttv_fmt};
use orchid_host::ctx::Ctx;
use orchid_host::execute::{ExecCtx, ExecResult};
use orchid_host::expr::ExprKind;
use orchid_host::extension::Extension;
use orchid_host::lex::lex;
use orchid_host::parse::{HostParseCtxImpl, parse_item, parse_items};
use orchid_host::parsed::{Item, ItemKind, ParsTokTree, ParsedMember, ParsedModule};
use orchid_host::subprocess::ext_command;
use orchid_host::system::init_systems;
use substack::Substack;
use tokio::io::{AsyncBufReadExt, BufReader, stdin};
use tokio::task::{LocalSet, spawn_local};

use crate::parse_folder::parse_folder;

#[derive(Parser, Debug)]
#[command(version, about, long_about)]
pub struct Args {
	#[arg(short, long, env = "ORCHID_EXTENSIONS", value_delimiter = ';')]
	extension: Vec<Utf8PathBuf>,
	#[arg(short, long, env = "ORCHID_DEFAULT_SYSTEMS", value_delimiter = ';')]
	system: Vec<String>,
	#[arg(short, long)]
	logs: bool,
	#[arg(short, long)]
	msg_logs: bool,
	#[command(subcommand)]
	command: Commands,
}

#[derive(Subcommand, Debug)]
pub enum Commands {
	Lex {
		#[arg(short, long)]
		file: Utf8PathBuf,
	},
	Parse {
		#[arg(short, long)]
		file: Utf8PathBuf,
	},
	Repl,
	Exec {
		#[arg(long)]
		proj: Option<Utf8PathBuf>,
		#[arg()]
		code: String,
	},
}

fn get_all_extensions<'a>(
	args: &'a Args,
	logger: &'a Logger,
	msg_logger: &'a Logger,
	ctx: &'a Ctx,
) -> impl Stream<Item = io::Result<Extension>> + 'a {
	try_stream(async |mut cx| {
		for ext_path in args.extension.iter() {
			let exe = if cfg!(windows) { ext_path.with_extension("exe") } else { ext_path.clone() };
			let init =
				ext_command(Command::new(exe.as_os_str()), logger.clone(), msg_logger.clone(), ctx.clone())
					.await?;
			cx.emit(Extension::new(init, logger.clone(), msg_logger.clone(), ctx.clone())?).await;
		}
		Ok(cx)
	})
}

#[tokio::main]
async fn main() -> io::Result<ExitCode> {
	let exit_code = Rc::new(RefCell::new(ExitCode::SUCCESS));
	let local_set = LocalSet::new();
	let exit_code1 = exit_code.clone();
	local_set.spawn_local(async move {
		let args = Args::parse();
		let ctx = &Ctx::new(Rc::new(|fut| mem::drop(spawn_local(fut))));
		let i = &ctx.i;
		let logger = Logger::new(if args.logs { LogStrategy::StdErr } else { LogStrategy::Discard });
		let msg_logger =
			Logger::new(if args.msg_logs { LogStrategy::StdErr } else { LogStrategy::Discard });
		let extensions = get_all_extensions(&args, &logger, &msg_logger, ctx)
			.try_collect::<Vec<Extension>>()
			.await
			.unwrap();
		match args.command {
			Commands::Lex { file } => {
				let (_, systems) = init_systems(&args.system, &extensions).await.unwrap();
				let mut file = File::open(file.as_std_path()).unwrap();
				let mut buf = String::new();
				file.read_to_string(&mut buf).unwrap();
				let lexemes = lex(i.i(&buf).await, sym!(usercode; i).await, &systems, ctx).await.unwrap();
				println!("{}", take_first(&ttv_fmt(&lexemes, &FmtCtxImpl { i }).await, true))
			},
			Commands::Parse { file } => {
				let (_, systems) = init_systems(&args.system, &extensions).await.unwrap();
				let mut file = File::open(file.as_std_path()).unwrap();
				let mut buf = String::new();
				file.read_to_string(&mut buf).unwrap();
				let lexemes = lex(i.i(&buf).await, sym!(usercode; i).await, &systems, ctx).await.unwrap();
				let Some(first) = lexemes.first() else {
					println!("File empty!");
					return;
				};
				let reporter = Reporter::new();
				let pctx = HostParseCtxImpl {
					rep: &reporter,
					systems: &systems,
					ctx: ctx.clone(),
					src: sym!(usercode; i).await,
				};
				let snip = Snippet::new(first, &lexemes);
				let ptree = parse_items(&pctx, Substack::Bottom, snip).await.unwrap();
				if let Some(errv) = reporter.errv() {
					eprintln!("{errv}");
					*exit_code1.borrow_mut() = ExitCode::FAILURE;
					return;
				}
				if ptree.is_empty() {
					eprintln!("File empty only after parsing, but no errors were reported");
					*exit_code1.borrow_mut() = ExitCode::FAILURE;
					return;
				}
				for item in ptree {
					println!("{}", take_first(&item.print(&FmtCtxImpl { i }).await, true))
				}
			},
			Commands::Repl => {
				let mut counter = 0;
				let mut imports = Vec::new();
				let usercode_path = sym!(usercode; i).await;
				let mut stdin = BufReader::new(stdin());
				loop {
					counter += 1;
					let (mut root, systems) = init_systems(&args.system, &extensions).await.unwrap();
					print!("\\.> ");
					std::io::stdout().flush().unwrap();
					let mut prompt = String::new();
					stdin.read_line(&mut prompt).await.unwrap();
					let name = i.i(&format!("_{counter}")).await;
					let path = usercode_path.suffix([name.clone()], i).await;
					let mut lexemes =
						lex(i.i(prompt.trim()).await, path.clone(), &systems, ctx).await.unwrap();
					let Some(discr) = lexemes.first() else { continue };
					if args.logs {
						println!("lexed: {}", take_first(&ttv_fmt(&lexemes, &FmtCtxImpl { i }).await, true));
					}
					let prefix_sr = SrcRange::zw(path.clone(), 0);
					let process_lexemes = async |lexemes: &[ParsTokTree]| {
						let snippet = Snippet::new(&lexemes[0], lexemes);
						let reporter = Reporter::new();
						let parse_ctx = HostParseCtxImpl {
							ctx: ctx.clone(),
							rep: &reporter,
							src: path.clone(),
							systems: &systems[..],
						};
						let parse_result = parse_item(&parse_ctx, Substack::Bottom, vec![], snippet).await;
						match reporter.merge(parse_result) {
							Ok(items) => Some(items),
							Err(e) => {
								eprintln!("{e}");
								None
							},
						}
					};
					let add_imports = |items: &mut Vec<Item>, imports: &[Import]| {
						items.extend(imports.iter().map(|import| Item::new(import.sr.clone(), import.clone())));
					};
					if discr.is_kw(i.i("import").await) {
						let Some(import_lines) = process_lexemes(&lexemes).await else { continue };
						imports.extend(import_lines.into_iter().map(|it| match it.kind {
							ItemKind::Import(imp) => imp,
							_ => panic!("Expected imports from import line"),
						}));
						continue;
					}
					if !discr.is_kw(i.i("let").await) {
						let prefix = [i.i("export").await, i.i("let").await, name.clone(), i.i("=").await];
						lexemes.splice(0..0, prefix.map(|n| Token::Name(n).at(prefix_sr.clone())));
					}
					let Some(mut new_lines) = process_lexemes(&lexemes).await else { continue };
					let const_decl = new_lines.iter().exactly_one().expect("Multiple lines from let");
					let input_sr = const_decl.sr.map_range(|_| 0..0);
					let const_name = match &const_decl.kind {
						ItemKind::Member(ParsedMember { name: const_name, .. }) => const_name.clone(),
						_ => panic!("Expected exactly one constant declaration from let"),
					};
					add_imports(&mut new_lines, &imports);
					imports.push(Import::new(input_sr.clone(), VPath::new(path.segs()), const_name.clone()));
					let new_module = ParsedModule::new(true, new_lines);
					let reporter = Reporter::new();
					root = root.add_parsed(&new_module, path.clone(), &reporter).await;
					eprintln!("parsed");
					let entrypoint =
						ExprKind::Const(path.suffix([const_name.clone()], i).await).at(input_sr.pos());
					let mut xctx = ExecCtx::new(ctx.clone(), logger.clone(), root.clone(), entrypoint).await;
					eprintln!("executed");
					xctx.set_gas(Some(1000));
					xctx.execute().await;
					match xctx.result() {
						ExecResult::Value(val) =>
							println!("{const_name} = {}", take_first(&val.print(&FmtCtxImpl { i }).await, false)),
						ExecResult::Err(e) => println!("error: {e}"),
						ExecResult::Gas(_) => println!("Ran out of gas!"),
					}
				}
			},
			Commands::Exec { proj, code } => {
				let reporter = Reporter::new();
				let path = sym!(usercode; i).await;
				let prefix_sr = SrcRange::zw(path.clone(), 0);
				let (mut root, systems) = init_systems(&args.system, &extensions).await.unwrap();
				if let Some(proj_path) = proj {
					let path = proj_path.into_std_path_buf();
					match parse_folder(&root, path, sym!(src; i).await, &reporter, ctx.clone()).await {
						Ok(r) => root = r,
						Err(e) => {
							eprintln!("{e}");
							*exit_code1.borrow_mut() = ExitCode::FAILURE;
							return;
						},
					}
				}
				let mut lexemes = lex(i.i(code.trim()).await, path.clone(), &systems, ctx).await.unwrap();
				if args.logs {
					println!("lexed: {}", take_first(&ttv_fmt(&lexemes, &FmtCtxImpl { i }).await, true));
				}
				let parse_ctx = HostParseCtxImpl {
					ctx: ctx.clone(),
					rep: &reporter,
					src: path.clone(),
					systems: &systems[..],
				};
				let prefix =
					[i.i("export").await, i.i("let").await, i.i("entrypoint").await, i.i("=").await];
				lexemes.splice(0..0, prefix.map(|n| Token::Name(n).at(prefix_sr.clone())));
				let snippet = Snippet::new(&lexemes[0], &lexemes);
				let parse_res = parse_item(&parse_ctx, Substack::Bottom, vec![], snippet).await;
				let entrypoint = match reporter.merge(parse_res) {
					Ok(items) => ParsedModule::new(true, items),
					Err(e) => {
						eprintln!("{e}");
						*exit_code1.borrow_mut() = ExitCode::FAILURE;
						return;
					},
				};
				let reporter = Reporter::new();
				let root = root.add_parsed(&entrypoint, path.clone(), &reporter).await;
				let expr = ExprKind::Const(sym!(usercode::entrypoint; i).await).at(prefix_sr.pos());
				let mut xctx = ExecCtx::new(ctx.clone(), logger.clone(), root, expr).await;
				xctx.set_gas(Some(1000));
				xctx.execute().await;
				match xctx.result() {
					ExecResult::Value(val) =>
						println!("{}", take_first(&val.print(&FmtCtxImpl { i }).await, false)),
					ExecResult::Err(e) => println!("error: {e}"),
					ExecResult::Gas(_) => println!("Ran out of gas!"),
				}
			},
		}
	});
	local_set.await;
	let x = *exit_code.borrow();
	Ok(x)
}