plum

// Functions/methods are named camelCase across this project (matching plum's own

// naming convention), not Rust's idiomatic snake_case — silence the resulting lint.

#![allow(non_snake_case)]

use std::fs;

use std::io::{self, Read};

use std::process;

use anyhow::{Context, Result};

use clap::{Parser, Subcommand};

use plum_core::formatSource;

mod editor;

use editor::EditorType;

#[derive(Parser)]

#[command(name = "plum", about = "The Plum language toolchain")]

struct Cli {

    #[command(subcommand)]

    command: Command,

}

#[derive(Subcommand)]

enum Command {

    /// Format a Plum source file

    Format {

        /// File to format (omit to use --stdin)

        file: Option<std::path::PathBuf>,

        /// Check if file is formatted; exit 1 if it would change

        #[arg(long)]

        check: bool,

        /// Read from stdin and write formatted source to stdout

        #[arg(long)]

        stdin: bool,

    },

    /// Compile a Plum source file to WASM

    Compile {

        /// Source file to compile

        file: std::path::PathBuf,

        /// Output path (default: input with .wasm extension)

        #[arg(short, long)]

        output: Option<std::path::PathBuf>,

        /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)

        #[arg(long, default_value = "libs")]

        lib_path: std::path::PathBuf,

    },

    /// Compile a Plum source file to WASM and immediately run it under wasmtime

    Run {

        /// Source file to compile and run

        file: std::path::PathBuf,

        /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)

        #[arg(long, default_value = "libs")]

        lib_path: std::path::PathBuf,

    },

    /// Compile a Plum source file to WASM and embed it into a wasmtime-backed

    /// native executable

    Build {

        /// Source file to compile

        file: std::path::PathBuf,

        /// Output executable path (default: input file's name, no extension)

        #[arg(short, long)]

        output: Option<std::path::PathBuf>,

        /// Root directory `import <path>` is resolved against (`import std/x` -> `<lib-path>/std/x.plum`)

        #[arg(long, default_value = "libs")]

        lib_path: std::path::PathBuf,

    },

    /// Install Plum syntax highlighting into an editor's configuration

    Editor {

        /// Editor to install support for

        editor: EditorType,

        /// Install for VSCode Insiders instead of stable VSCode (ignored for helix)

        #[arg(long)]

        insiders: bool,

    },

}

fn main() {

    if let Err(e) = run() {

        eprintln!("error: {e:#}");

        process::exit(1);

    }

}

fn run() -> Result<()> {

    let cli = Cli::parse();

    match cli.command {

        Command::Format { file, check, stdin } => cmdFormat(file, check, stdin),

        Command::Compile { file, output, lib_path } => cmdCompile(file, output, lib_path),

        Command::Run { file, lib_path } => cmdRun(file, lib_path),

        Command::Build { file, output, lib_path } => cmdBuild(file, output, lib_path),

        Command::Editor { editor, insiders } => editor::install(editor, insiders),

    }

}

fn cmdFormat(

    file: Option<std::path::PathBuf>,

    check: bool,

    use_stdin: bool,

) -> Result<()> {

    if use_stdin && check {

        anyhow::bail!("--check cannot be used with --stdin");

    }

    if use_stdin {

        let mut source = String::new();

        io::stdin()

            .read_to_string(&mut source)

            .context("failed to read stdin")?;

        let formatted = formatSource(&source).map_err(|e| anyhow::anyhow!("{e}"))?;

        print!("{formatted}");

        return Ok(());

    }

    let path = file.ok_or_else(|| anyhow::anyhow!("provide a file path or --stdin"))?;

    let source =

        fs::read_to_string(&path).with_context(|| format!("failed to read {}", path.display()))?;

    let formatted = formatSource(&source).map_err(|e| anyhow::anyhow!("{e}"))?;

    if check {

        if source != formatted {

            eprintln!("{}: would reformat", path.display());

            process::exit(1);

        }

        return Ok(());

    }

    if source != formatted {

        fs::write(&path, formatted.as_bytes())

            .with_context(|| format!("failed to write {}", path.display()))?;

    }

    Ok(())

}

fn compileToWasm(file: &std::path::Path, lib_path: &std::path::Path) -> Result<Vec<u8>> {

    let ast = plum_core::loadAndMerge(file, lib_path)

        .map_err(|e| anyhow::anyhow!("{e}"))?;

    // Type check

    if let Err(errors) = plum_checker::checkSource(&ast) {

        for e in &errors {

            eprintln!("type error: {}", e.message);

        }

        process::exit(1);

    }

    // Codegen

    plum_wasm_codegen::compileSource(&ast).map_err(|e| anyhow::anyhow!("codegen error: {e}"))

}

fn cmdCompile(

    file: std::path::PathBuf,

    output: Option<std::path::PathBuf>,

    lib_path: std::path::PathBuf,

) -> Result<()> {

    let wasm_bytes = compileToWasm(&file, &lib_path)?;

    let out_path = output.unwrap_or_else(|| file.with_extension("wasm"));

    fs::write(&out_path, &wasm_bytes)

        .with_context(|| format!("failed to write {}", out_path.display()))?;

    eprintln!("compiled {} → {}", file.display(), out_path.display());

    Ok(())

}

/// Builds the `Extern`s that satisfy a compiled Plum module's host imports (today,

/// only `plum::printLn`) in declaration order, matching each one's exact `FuncType`

/// (its `Str` param is a concrete wasm-gc array type, so the host function must be

/// built from the module's own reported type rather than a generic `Rooted<ArrayRef>`

/// wrapper, which would carry the wrong, unrelated top-array type and fail to

/// instantiate).

fn hostImports(store: &mut wasmtime::Store<()>, module: &wasmtime::Module) -> Result<Vec<wasmtime::Extern>> {

    module.imports().map(|imp| {

        match (imp.module(), imp.name()) {

            ("plum", "printLn") => {

                let func_ty = imp.ty().func().cloned()

                    .ok_or_else(|| anyhow::anyhow!("plum::printLn import must be a function"))?;

                Ok(wasmtime::Extern::Func(wasmtime::Func::new(&mut *store, func_ty, |mut caller, params, _results| {

                    let wasmtime::Val::AnyRef(Some(s)) = &params[0] else {

                        return Err(wasmtime::Error::msg("printLn expects a Str argument"));

                    };

                    let arr = s.unwrap_array(&caller)?;

                    let len = arr.len(&caller)?;

                    let mut buf = vec![0u8; len as usize];

                    arr.copy_to_i8_slice(&mut caller, &mut buf)?;

                    println!("{}", String::from_utf8_lossy(&buf));

                    Ok(())

                })))

            }

            (m, n) => anyhow::bail!("unsupported host import {m}::{n}"),

        }

    }).collect()

}

fn cmdRun(file: std::path::PathBuf, lib_path: std::path::PathBuf) -> Result<()> {

    let wasm_bytes = compileToWasm(&file, &lib_path)?;

    // GC + typed function references are required to load modules containing

    // Plum's structs/enums/strings/closures (see docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).

    let mut config = wasmtime::Config::new();

    config.wasm_gc(true);

    config.wasm_function_references(true);

    let engine = wasmtime::Engine::new(&config)

        .map_err(|e| anyhow::anyhow!("failed to construct wasmtime engine: {e}"))?;

    let module = wasmtime::Module::new(&engine, &wasm_bytes)

        .map_err(|e| anyhow::anyhow!("compiled wasm failed to load: {e}"))?;

    let mut store = wasmtime::Store::new(&engine, ());

    let imports = hostImports(&mut store, &module)?;

    let instance = wasmtime::Instance::new(&mut store, &module, &imports)

        .map_err(|e| anyhow::anyhow!("module failed to instantiate: {e}"))?;

    // `main` returns `i64` unless it's declared `Unit` (no return value), in

    // which case codegen gives it an empty wasm result type instead.

    if let Ok(main) = instance.get_typed_func::<(), i64>(&mut store, "main") {

        match main.call(&mut store, ()) {

            Ok(result) => println!("{result}"),

            Err(trap) => {

                eprintln!("error: {trap}");

                process::exit(1);

            }

        }

        return Ok(());

    }

    let main = instance

        .get_typed_func::<(), ()>(&mut store, "main")

        .map_err(|_| anyhow::anyhow!("module has no `main` export with signature () -> i64 or () -> ()"))?;

    if let Err(trap) = main.call(&mut store, ()) {

        eprintln!("error: {trap}");

        process::exit(1);

    }

    Ok(())

}

/// Path to the `plum-runtime` crate, resolved relative to `plum-cli`'s own

/// manifest directory (baked in at compile time) rather than the current

/// working directory, so `plum build` works no matter where it's invoked from.

fn runtimeCrateDir() -> std::path::PathBuf {

    std::path::Path::new(env!("CARGO_MANIFEST_DIR"))

        .parent()

        .expect("plum-cli should live inside the workspace root")

        .join("plum-runtime")

}

fn cmdBuild(

    file: std::path::PathBuf,

    output: Option<std::path::PathBuf>,

    lib_path: std::path::PathBuf,

) -> Result<()> {

    let wasm_bytes = compileToWasm(&file, &lib_path)?;

    let stem = file

        .file_stem()

        .ok_or_else(|| anyhow::anyhow!("invalid source file path {}", file.display()))?;

    let wasm_path = std::env::temp_dir().join(format!(

        "plum-build-{}-{}.wasm",

        stem.to_string_lossy(),

        process::id()

    ));

    fs::write(&wasm_path, &wasm_bytes)

        .with_context(|| format!("failed to write {}", wasm_path.display()))?;

    let wasm_abs_path = fs::canonicalize(&wasm_path)

        .with_context(|| format!("failed to resolve {}", wasm_path.display()))?;

    let runtime_dir = runtimeCrateDir();

    eprintln!("building executable (embedding wasm via wasmtime)...");

    let status = process::Command::new("cargo")

        .args(["build", "--release", "--manifest-path"])

        .arg(runtime_dir.join("Cargo.toml"))

        .env("PLUM_WASM_PATH", &wasm_abs_path)

        .status()

        .context("failed to run cargo — is it installed and on PATH?")?;

    let _ = fs::remove_file(&wasm_path);

    if !status.success() {

        anyhow::bail!("cargo build failed");

    }

    let built_bin = runtime_dir.join("target/release/plum-runtime");

    let out_path = output.unwrap_or_else(|| std::path::PathBuf::from(stem));

    fs::copy(&built_bin, &out_path).with_context(|| {

        format!("failed to copy {} to {}", built_bin.display(), out_path.display())

    })?;

    eprintln!("built {} → {}", file.display(), out_path.display());

    Ok(())

}