plum

#![allow(non_snake_case)]
use plum_wasm_codegen::compileSource;
use plum_core::AstParser;

fn examplesDir() -> std::path::PathBuf {
    std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples")
}

fn parseFile(name: &str) -> plum_core::ast::Source {
    let path = examplesDir().join(name);
    let src = std::fs::read_to_string(&path).unwrap_or_else(|e| panic!("failed to read {}: {}", path.display(), e));
    let mut parser = tree_sitter::Parser::new();
    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();
    let tree = parser.parse(&src, None).unwrap_or_else(|| panic!("failed to parse {}", path.display()));
    assert!(!tree.root_node().has_error(), "{} has a parse error", path.display());
    let ap = AstParser::new(&src);
    ap.parseSource(tree.root_node())
}

/// See the identically-named helper in codegen_tests.rs for why both features
/// are needed (part of the wasm-gc migration, docs/superpowers/plans/2026-07-25-wasm-gc-migration.md).
fn gcEngine() -> wasmtime::Engine {
    let mut config = wasmtime::Config::new();
    config.wasm_gc(true);
    config.wasm_function_references(true);
    wasmtime::Engine::new(&config).expect("engine with GC config should construct")
}

fn assertCompiles(name: &str) -> Vec<u8> {
    let source = parseFile(name);
    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("{} failed to compile: {}", name, e));
    let result = wasmparser::validate(&bytes);
    assert!(result.is_ok(), "{} produced invalid wasm: {:?}", name, result.err());
    bytes
}

/// Examples that stick to currently-supported codegen features (primitives, control
/// flow, classes/methods) must actually compile to valid wasm — not just parse and
/// type-check.
#[test]
fn basicsCompiles() {
    assertCompiles("basics.plum");
}

#[test]
fn controlFlowCompiles() {
    assertCompiles("control_flow.plum");
}

#[test]
fn functionsCompiles() {
    assertCompiles("functions.plum");
}

#[test]
fn typesCompiles() {
    // Only class/trait/enum declarations, no function bodies to lower — should still
    // produce a valid (if unexciting) module.
    assertCompiles("types.plum");
}

#[test]
fn methodsCompilesAndRunsCorrectly() {
    let bytes = assertCompiles("methods.plum");

    let engine = gcEngine();
    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
    let mut store = wasmtime::Store::new(&engine, ());
    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
    let main = instance
        .get_typed_func::<(), i64>(&mut store, "main")
        .expect("main should have signature () -> i64");
    let result = main.call(&mut store, ()).expect("main should not trap");
    // makeCat() -> Cat(age: 3); a = getAge() = 3; b = birthday() = 4;
    // w.innerAge() = inner.age = 3 => 3 + 4 + 3 = 10
    assert_eq!(result, 10);
}

/// match.plum now exercises fully-supported syntax (general enum tag and
/// constructor patterns) and must compile and run correctly end to end.
#[test]
fn matchExampleCompilesAndRunsCorrectly() {
    let bytes = assertCompiles("match.plum");
    let engine = gcEngine();
    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
    let mut store = wasmtime::Store::new(&engine, ());
    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
    let main = instance
        .get_typed_func::<(), i64>(&mut store, "main")
        .expect("main should have signature () -> i64");
    let result = main.call(&mut store, ()).expect("main should not trap");
    // describeOption(Some(5)) = 5
    assert_eq!(result, 5);
}

/// closures.plum exercises non-capturing closures, capturing closures (snapshot-by-value),
/// and closures passed directly as call arguments.
#[test]
fn closuresExampleCompilesAndRunsCorrectly() {
    let bytes = assertCompiles("closures.plum");
    let engine = gcEngine();
    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
    let mut store = wasmtime::Store::new(&engine, ());
    let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
    let main = instance
        .get_typed_func::<(), i64>(&mut store, "main")
        .expect("main should have signature () -> i64");
    // each(|v| v * 3) = 5 * 3 = 15; useCapturingClosure() = cb(5) with offset=100 snapshot
    // captured at creation = 5 + 100 = 105; total = 15 + 105 = 120.
    assert_eq!(main.call(&mut store, ()).expect("main should not trap"), 120);
}

/// strings.plum exercises string interpolation (plain literals, `Str`/`Int`
/// interpolation, and escape sequences) — it has no `main` to execute, so (matching
/// `basicsCompiles`/`controlFlowCompiles`/etc. above for other main-less examples)
/// this only checks that it compiles to a valid module.
#[test]
fn stringsExampleCompiles() {
    assertCompiles("strings.plum");
}

/// io.plum exercises `extern fun` (see `Fn.is_extern`/`FnBody::Extern` in
/// plum-core/src/ast.rs and their handling in plum-wasm-codegen/src/lib.rs) — it
/// declares its own `extern fun printLn(s: Str)` (redeclared locally rather than a
/// real `import std/os`, to keep this fixture self-contained for the single-file
/// parse/check this test and plum-checker's examples test do), which codegen turns
/// into a genuine wasm `(import "plum" "printLn" ...)` instead of a compiled body.
/// Runs it for real, providing the import as a host function that records what
/// it's called with, to prove both the wasm-level import wiring AND the actual
/// bytes handed across the host boundary are correct.
#[test]
fn ioExampleCompilesAndRunsCorrectly() {
    let bytes = assertCompiles("io.plum");
    let engine = gcEngine();
    let module = wasmtime::Module::new(&engine, &bytes).expect("module should be loadable");
    let mut store = wasmtime::Store::new(&engine, ());

    let printed: std::sync::Arc<std::sync::Mutex<Vec<String>>> = Default::default();
    let printed_for_closure = printed.clone();
    let import_ty = module
        .imports()
        .find(|imp| imp.module() == "plum" && imp.name() == "printLn")
        .expect("io.plum should import plum::printLn")
        .ty()
        .func()
        .cloned()
        .expect("plum::printLn import should be a function");
    let print_ln = wasmtime::Func::new(&mut store, import_ty, move |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)?;
        printed_for_closure.lock().unwrap().push(String::from_utf8_lossy(&buf).into_owned());
        Ok(())
    });

    let instance = wasmtime::Instance::new(&mut store, &module, &[wasmtime::Extern::Func(print_ln)])
        .expect("module should instantiate");
    let main = instance
        .get_typed_func::<(), ()>(&mut store, "main")
        .expect("main should have signature () -> ()");
    main.call(&mut store, ()).expect("main should not trap");

    assert_eq!(*printed.lock().unwrap(), vec!["hello from plum".to_string(), "hello, world!".to_string()]);
}