use std::io::Write;
use std::process::ExitCode;
use qleisli::frontend::diagnostic::Diagnostic;
use qleisli::frontend::documentation::render_markdown;
use qleisli::frontend::project::read_source_file;
#[path = "qleisli/artifacts.rs"]
mod artifacts;
#[path = "qleisli/interop.rs"]
mod interop;
#[path = "qleisli/json.rs"]
mod json;
#[path = "qleisli/options.rs"]
mod options;
#[path = "qleisli/samples.rs"]
mod samples;
#[path = "qleisli/sized.rs"]
mod sized;
#[path = "qleisli/source_commands.rs"]
mod source_commands;
fn write_stdout(bytes: &[u8], description: &str) -> ExitCode {
match std::io::stdout().lock().write_all(bytes) {
Ok(()) => ExitCode::SUCCESS,
Err(error) => {
eprintln!("could not write {description}: {error}");
ExitCode::FAILURE
}
}
}
fn report(root: &std::path::Path, error: Diagnostic) {
if let Some(p) = error.primary {
eprintln!(
"{}:{}:{}: {}: {}",
p.path.display(),
p.line,
p.column,
error.code,
error.message
);
} else {
eprintln!("{}: {}: {}", root.display(), error.code, error.message);
}
}
fn main() -> ExitCode {
let args: Vec<_> = std::env::args_os().skip(1).collect();
if args.first().is_some_and(|arg| arg == "sized") {
return sized::run(&args[1..]);
}
if args.first().is_some_and(|arg| arg == "interop") {
return interop::run(&args[1..]);
}
if args.iter().any(|arg| arg == "--format=json") {
return json::run(&args);
}
let Some(mut options) = options::Options::parse(&args, false) else {
eprintln!("{}", options::USAGE);
return ExitCode::from(2);
};
if options.qrate {
match qleisli::frontend::project::QrateSource::select(&options.path) {
Ok(root) => {
options.path = root.path().to_owned();
options.selected_root = Some(root);
}
Err(error) => {
report(&options.path, error);
return ExitCode::FAILURE;
}
}
}
let source_root = &options.path;
if options.command != "verify-ir" && options.command != "doc" {
for warning in
qleisli::frontend::project::manifest_warnings(source_root).unwrap_or_default()
{
eprintln!("warning: {}", warning.message);
}
}
if matches!(options.command.as_str(), "emit-ir" | "verify-ir") {
return match artifacts::execute(&options) {
Ok(artifacts::Success::Emitted(path)) => write_stdout(
format!("emitted independently verified IR: {path}\n").as_bytes(),
"emission result",
),
Ok(artifacts::Success::Verified(request)) => write_stdout(
format!("verified IR; request_checked: {request}\n").as_bytes(),
"verification result",
),
Err(artifacts::Failure::Source(error)) => {
report(source_root, error);
ExitCode::FAILURE
}
Err(artifacts::Failure::Artifact(error)) => {
eprintln!("{error}");
ExitCode::FAILURE
}
};
}
if options.command == "doc" {
let source = match read_source_file(source_root, options.policy) {
Ok(source) => source,
Err(error) => {
report(source_root, error);
return ExitCode::FAILURE;
}
};
return match render_markdown(&source) {
Ok(markdown) => write_stdout(markdown.as_bytes(), "documentation"),
Err(error) => {
eprintln!("{}: {error}", source_root.display());
ExitCode::FAILURE
}
};
}
match source_commands::execute(&options, source_root) {
Ok(source_commands::Success::Checked) => write_stdout(
format!(
"checked source and verified IR: {}\n",
source_root.display()
)
.as_bytes(),
"check result",
),
Err(source_commands::Failure::Source(error)) => {
report(source_root, error);
ExitCode::FAILURE
}
Ok(source_commands::Success::Samples { shots, .. }) => {
let mut text = String::new();
for sample in shots {
if sample.bits.is_empty() {
text.push_str("()");
}
for bit in sample.bits {
text.push(if bit { '1' } else { '0' });
}
text.push('\n');
}
write_stdout(text.as_bytes(), "sample results")
}
Ok(source_commands::Success::Distribution(distribution)) => {
use std::fmt::Write as _;
let mut text = String::new();
for (outcome, probability) in distribution {
let label: String = outcome
.iter()
.map(|bit| if *bit { '1' } else { '0' })
.collect();
writeln!(
text,
"{}: {probability:.12e}",
if label.is_empty() { "()" } else { &label }
)
.expect("writing to String");
}
write_stdout(text.as_bytes(), "distribution")
}
Err(source_commands::Failure::Simulation(error)) => {
eprintln!("{error}");
ExitCode::FAILURE
}
}
}