plum

#![allow(non_snake_case)]

use plum_wasm_codegen::compileSource;

use plum_core::AstParser;

use wasm_encoder::Encode;

fn parse(src: &str) -> plum_core::ast::Source {

    let mut parser = tree_sitter::Parser::new();

    parser.set_language(&tree_sitter_plum::LANGUAGE.into()).unwrap();

    let tree = parser.parse(src, None).unwrap();

    let ap = AstParser::new(src);

    ap.parseSource(tree.root_node())

}

/// The wasm-gc migration (docs/superpowers/plans/2026-07-25-wasm-gc-migration.md)

/// needs both `wasm_gc` and `wasm_function_references` enabled — confirmed

/// empirically (see the `wasmtimeGcConfig*` tests below) rather than assumed from

/// docs, since wasmtime's own doc comment on `Config::wasm_gc` warns its GC support

/// is still in progress. Every test that instantiates/runs compiled output uses

/// this shared engine so the whole harness stays on one config.

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")

}

#[test]

fn compilesToValidWasm() {

    let src = "fun add(a: Int, b: Int) -> Int =\n  a + b\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    // Valid WASM starts with the magic number

    assert_eq!(&bytes[0..4], b"\0asm");

    assert_eq!(&bytes[4..8], &[1, 0, 0, 0]); // version 1

}

#[test]

fn outputValidates() {

    let src = "fun add(a: Int, b: Int) -> Int =\n  a + b\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    // wasmparser should accept the output

    let result = wasmparser::validate(&bytes);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

}

#[test]

fn factorialCompiles() {

    let src = "\

fun factorial(x: Int) -> Int =

  if x < 2

    return 1

  return x * factorial(x - 1)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("factorial should compile");

    assert_eq!(&bytes[0..4], b"\0asm");

    let result = wasmparser::validate(&bytes);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

}

#[test]

fn give42CompilesAndExports() {

    let src = "fun give42() -> Int =\n  42\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(&bytes[0..4], b"\0asm");

    let result = wasmparser::validate(&bytes);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

}

fn assertValid(src: &str) -> Vec<u8> {

    let source = parse(src);

    let bytes = compileSource(&source).unwrap_or_else(|e| panic!("compile failed for {:?}: {}", src, e));

    let result = wasmparser::validate(&bytes);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

    bytes

}

#[test]

fn boolLiteralsCompile() {

    assertValid("fun main() -> Bool =\n  True\n");

    assertValid("fun main() -> Bool =\n  False\n");

}

#[test]

fn stringLiteralCompiles() {

    assertValid("fun main() -> Str =\n  \"hello\"\n");

}

#[test]

fn emptyStringLiteralCompiles() {

    assertValid("fun main() -> Str =\n  \"\"\n");

}

#[test]

fn stringInterpolationOfAnIntRunsCorrectly() {

    let src = "fun main() -> Str =\n  x = 42\n  \"{x}\"\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "42");

}

#[test]

fn stringInterpolationOfANegativeIntRunsCorrectly() {

    let src = "fun main() -> Str =\n  x = -7\n  \"{x}\"\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "-7");

}

#[test]

fn stringInterpolationOfZeroRunsCorrectly() {

    let src = "fun main() -> Str =\n  x = 0\n  \"{x}\"\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "0");

}

#[test]

fn stringInterpolationWithSurroundingTextAndMultipleInterpsRunsCorrectly() {

    let src = "fun main() -> Str =\n  count = 3\n  total = 10\n  \"{count} of {total} complete\"\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "3 of 10 complete");

}

#[test]

fn stringInterpolationOfAStrRunsCorrectly() {

    let src = "fun greet(name: Str) -> Str =\n  \"Hello, {name}!\"\n\nfun main() -> Str =\n  greet(\"World\")\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "Hello, World!");

}

#[test]

fn stringInterpolationOfABoolRunsCorrectly() {

    let src = "fun main() -> Str =\n  b = True\n  \"is {b}\"\n";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainStr(&bytes), "is True");

}

#[test]

fn stringInterpolationOfAFloatIsAClearError() {

    // Float-to-decimal-string formatting is a substantial separate undertaking

    // (correct rounding needs something like Grisu/Ryu); scoped out for now with

    // an explicit error rather than emitting an incorrect conversion.

    let src = "fun main() -> Str =\n  x = 1.5\n  \"{x}\"\n";

    let source = parse(src);

    let err = compileSource(&source).expect_err("float interpolation should not silently compile");

    assert!(err.contains("Float"), "got: {}", err);

}

#[test]

fn floatArithmeticAndNegationCompile() {

    assertValid("fun main(x: Float) -> Float =\n  y = -x\n  y + 1.5\n");

}

#[test]

fn classFieldAndMethodCompile() {

    let src = "\

type Cat =

  name: Str

  age: Int

  fun getAge() -> Int =

    self.age

fun makeCat() -> Int =

  c = Cat(name: \"x\", age: 3)

  c.getAge()

";

    assertValid(src);

}

#[test]

fn nestedClassCallCompiles() {

    let src = "\

type Pair =

  a: Int

  b: Int

type Wrapper =

  inner: Pair

  tag: Int

fun make() -> Int =

  w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)

  w.tag

";

    assertValid(src);

}

#[test]

fn matchWithIntAndWildcardCompiles() {

    let src = "fun main(a: Int) -> Int =\n  match a\n    1 =>\n      return 10\n    _ =>\n      return 0\n";

    assertValid(src);

}

#[test]

fn matchBindingPatternCompiles() {

    let src = "fun main(a: Int) -> Int =\n  match a\n    x =>\n      return x\n";

    assertValid(src);

}

#[test]

fn matchInlineCaseBodyCompiles() {

    // Case bodies can be a single inline expression, not just an indented block.

    let src = "fun main(a: Int) =\n  match a\n    1 => 10\n    _ => 0\n";

    assertValid(src);

}

#[test]

fn matchBoolVariantPatternCompiles() {

    let src = "fun main(a: Bool) -> Int =\n  match a\n    True =>\n      return 1\n    False =>\n      return 0\n";

    assertValid(src);

}

#[test]

fn matchStringPatternIsAClearError() {

    let src = "fun main(a: Str) -> Int =\n  match a\n    \"x\" =>\n      1\n    _ =>\n      0\n";

    let source = parse(src);

    let err = compileSource(&source).expect_err("string match patterns are not yet supported");

    assert!(err.contains("string match"), "got: {}", err);

}

#[test]

fn nestedConstructorPatternMatchesAndBindsRunsCorrectly() {

    let src = "\

enum Option =

  | Some[Int]

  | None

enum Nested =

  | Wrap[Option]

  | Empty

fun f(n: Nested) -> Int =

  match n

    Wrap(Some(v)) =>

      return v

    Wrap(None) =>

      return -1

    Empty =>

      return 0

fun main() -> Int =

  f(Wrap(Some(5)))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 5);

}

#[test]

fn nestedConstructorPatternMismatchFallsThroughToNextCaseRunsCorrectly() {

    // `Wrap(Some(v))` shouldn't match a runtime `Wrap(None)` — codegen must fall

    // through to the next *top-level* case, not just fail to bind `v`.

    let src = "\

enum Option =

  | Some[Int]

  | None

enum Nested =

  | Wrap[Option]

  | Empty

fun f(n: Nested) -> Int =

  match n

    Wrap(Some(v)) =>

      return v

    Wrap(None) =>

      return -1

    Empty =>

      return 0

fun main() -> Int =

  f(Wrap(None))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), -1);

}

#[test]

fn nestedConstructorPatternAgainstASpecializedGenericEnumRunsCorrectly() {

    // Exercises monomorphize.rs's recursive mangling: the outer `Full(...)` pattern

    // matches against `Box`'s own specialization, but the *inner* `Some(v)`/`None`

    // sub-pattern matches against `Box`'s generic field type (`Option`, itself

    // specialized to `Option$Int`) — each level needs its own mangling table, not

    // just the outermost one.

    let src = "\

enum Option =

  | Some[T]

  | None

enum Box =

  | Full[T]

  | Empty

fun unwrap(b: Box) -> Int =

  match b

    Full(Some(v)) => v

    Full(None) => -1

    Empty => 0

fun main() -> Int =

  unwrap(Full(Some(7)))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn doublyNestedConstructorPatternRunsCorrectly() {

    // `Some(Some(v))` — two levels of nesting, proving the recursion isn't just

    // one level deep.

    let src = "\

enum Option =

  | Some[Option]

  | None

fun unwrapTwice(o: Option) -> Int =

  match o

    Some(Some(None)) => 1

    Some(None) => 2

    None => 3

    _ => 0

fun main() -> Int =

  unwrapTwice(Some(Some(None)))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 1);

}

/// Runs `main`'s wasm bytes and returns its i64 result. wasm's own validator

/// (via wasmparser, above) only proves the module is well-formed — it can't catch

/// wrong *values*, so these tests actually execute the compiled output.

fn runMain(bytes: &[u8]) -> i64 {

    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");

    main.call(&mut store, ()).expect("main should not trap")

}

fn runMainF64(bytes: &[u8]) -> f64 {

    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::<(), f64>(&mut store, "main")

        .expect("main should have signature () -> f64");

    main.call(&mut store, ()).expect("main should not trap")

}

/// Runs a `() -> Str`-returning `main`, reading the returned `array<i8>` GC value

/// back out byte-by-byte via wasmtime's host-side GC ref API (`Str` has no length

/// prefix of its own now — `array.len` is native, see Decision 4 of the wasm-gc

/// migration plan) — untyped `Func::call` is used because `main`'s wasm return type

/// is a concrete `(ref $Str)`, not one `get_typed_func` can name directly.

fn runMainStr(bytes: &[u8]) -> String {

    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_func(&mut store, "main").expect("module should export main");

    let mut results = [wasmtime::Val::null_any_ref()];

    main.call(&mut store, &[], &mut results).expect("main should not trap");

    let any_ref = match &results[0] {

        wasmtime::Val::AnyRef(Some(r)) => *r,

        other => panic!("main should return a non-null anyref (Str), got {:?}", other),

    };

    let array = any_ref.unwrap_array(&store).expect("Str's returned anyref should be a GC array");

    let len = array.len(&store).expect("array.len should succeed");

    let mut bytes_out = Vec::with_capacity(len as usize);

    for i in 0..len {

        let byte = match array.get(&mut store, i).expect("array.get should succeed") {

            wasmtime::Val::I32(b) => b as u8,

            other => panic!("Str array element should be i32, got {:?}", other),

        };

        bytes_out.push(byte);

    }

    String::from_utf8(bytes_out).expect("string bytes should be valid utf8")

}

#[test]

fn factorialRunsCorrectly() {

    let src = "\

fun factorial(x: Int) -> Int =

  if x < 2

    return 1

  return x * factorial(x - 1)

fun main() -> Int =

  factorial(5)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 120);

}

#[test]

fn classFieldAndMethodRunCorrectly() {

    let src = "\

type Cat =

  name: Str

  age: Int

  fun getAge() -> Int =

    self.age

fun main() -> Int =

  c = Cat(name: \"x\", age: 7)

  c.getAge()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn nestedMethodDeclarationRunsCorrectly() {

    let src = "\

type Cat =

  name: Str

  age: Int

  fun getAge(self) -> Int =

    self.age

fun main() -> Int =

  c = Cat(name: \"x\", age: 7)

  c.getAge()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn enumDiscriminantValueFieldAccessRunsCorrectlyForEachVariant() {

    let src = "\

enum Step(n: Int) =

  | ReadMin(10)

  | ReadMax(20)

  fun toNumber(self) -> Int =

    self.n

fun main() -> Int =

  ReadMin.toNumber() * 100 + ReadMax.toNumber()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 1020);

}

#[test]

fn enumDiscriminantValueMatchesByVariantNameCorrectly() {

    let src = "\

enum Step(n: Int) =

  | ReadMin(10)

  | ReadMax(20)

fun toNumber(s: Step) -> Int =

  match s

    ReadMin => 1

    ReadMax => 2

fun main() -> Int =

  toNumber(ReadMin) * 10 + toNumber(ReadMax)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 12);

}

#[test]

fn nestedClassCallRunsCorrectly() {

    let src = "\

type Pair =

  a: Int

  b: Int

type Wrapper =

  inner: Pair

  tag: Int

fun main() -> Int =

  w = Wrapper(inner: Pair(a: 11, b: 22), tag: 99)

  w.inner.b

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 22);

}

#[test]

fn repeatedClassCallInALoopDoesNotAlias() {

    // Regression test: class instances are bump-allocated at *runtime* (via a

    // mutable wasm global), not at a compile-time-fixed address — otherwise every

    // iteration's `Box(...)` would alias the same memory and this would sum to 5*4=20

    // instead of 0+1+2+3+4=10.

    let src = "\

type Box =

  v: Int

fun sumBoxes() -> Int =

  total = 0

  for i := range 5

    b = Box(v: i)

    total = total + b.v

  return total

fun main() -> Int =

  sumBoxes()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 10);

}

#[test]

fn matchIntAndWildcardRunCorrectly() {

    let src = "\

fun classify(a: Int) -> Int =

  match a

    1 =>

      return 100

    2 =>

      return 200

    _ =>

      return 0

fun main() -> Int =

  classify(2)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 200);

}

#[test]

fn matchBoolVariantPatternRunsCorrectly() {

    // Regression test: True/False are built-in Bool variants and must be treated as

    // tag comparisons, not bindings, even without an explicit `enum Bool` in this

    // source file — otherwise the first arm always "matches" (as a rebinding) and

    // `pick(False)` would wrongly return 1.

    let src = "\

fun pick(a: Bool) -> Int =

  match a

    True =>

      return 1

    False =>

      return 0

fun main() -> Int =

  pick(False)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 0);

}

#[test]

fn lowercaseSingleWordFunctionCallRunsCorrectly() {

    // Regression test: `factorial(...)` (an all-lowercase, no-uppercase, no-underscore

    // callee) used to fail to parse at all — `var_identifier` and `fn_identifier` both

    // matched its text and the grammar's lexer would nondeterministically commit to

    // `var_identifier`, breaking every such call site.

    let src = "\

fun double(n: Int) -> Int =

  n * 2

fun main() -> Int =

  double(21)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn assertTrapsOnFalseAndPassesThroughOnTrue() {

    let src_ok = "\

fun check(n: Int) -> Int =

  assert n > 0

  n

fun main() -> Int =

  check(5)

";

    let source = parse(src_ok);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 5);

    let src_trap = "\

fun check(n: Int) -> Int =

  assert n > 0

  n

fun main() -> Int =

  check(-1)

";

    let source = parse(src_trap);

    let bytes = compileSource(&source).expect("compile failed");

    let engine = gcEngine();

    let module = wasmtime::Module::new(&engine, &bytes).unwrap();

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

    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();

    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();

    let err = main.call(&mut store, ()).expect_err("a false assert should trap, not silently continue");

    assert_eq!(err.downcast_ref::<wasmtime::Trap>(), Some(&wasmtime::Trap::UnreachableCodeReached), "got: {}", err);

}

#[test]

fn todoTrapsAtRuntime() {

    // `todo` marks an unimplemented body — it must trap, not silently do nothing.

    let src = "\

fun notDoneYet() -> Int =

  todo

fun main() -> Int =

  notDoneYet()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    let engine = gcEngine();

    let module = wasmtime::Module::new(&engine, &bytes).unwrap();

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

    let instance = wasmtime::Instance::new(&mut store, &module, &[]).unwrap();

    let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();

    let err = main.call(&mut store, ()).expect_err("todo should trap");

    assert_eq!(err.downcast_ref::<wasmtime::Trap>(), Some(&wasmtime::Trap::UnreachableCodeReached), "got: {}", err);

}

#[test]

fn payloadFreeVariantConstructionCompiles() {

    let src = "\

enum Color =

  | Red

  | Green

  | Blue

fun main() -> Int =\n  x = Green\n  0\n";

    assertValid(src);

}

#[test]

fn payloadVariantConstructionCompilesAndRuns() {

    let src = "\

enum Option =

  | Some[Int]

  | None

fun unwrapOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      return v

    None =>

      return default

fun main() -> Int =

  unwrapOr(Some(7), 0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn multiFieldVariantConstructionCompilesAndRuns() {

    let src = "\

enum Shape =

  | Rect[Int, Int]

  | Circle[Int]

fun area(s: Shape) -> Int =

  match s

    Rect(w, h) =>

      return w * h

    Circle(r) =>

      return r * r

fun main() -> Int =

  area(Rect(3, 4))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 12);

}

#[test]

fn nonBoolBareTagPatternRunsCorrectly() {

    let src = "\

enum Color =

  | Red

  | Green

  | Blue

fun code(c: Color) -> Int =

  match c

    Red =>

      return 1

    Green =>

      return 2

    Blue =>

      return 3

fun main() -> Int =

  code(Green)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 2);

}

#[test]

fn constructorPatternWildcardFieldRunsCorrectly() {

    let src = "\

enum Option =

  | Some[Int]

  | None

fun isSome(o: Option) -> Int =

  match o

    Some(_) =>

      return 1

    None =>

      return 0

fun main() -> Int =

  isSome(Some(99))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 1);

}

#[test]

fn constructorPatternDoesNotMisfireOnPayloadFreeSibling() {

    // Regression test: `None` is a small-int tag, not a heap pointer. The

    // constructor-pattern arm for `Some(v)` must not treat a payload-free

    // sibling value as if it were a pointer to a `Some` payload.

    let src = "\

enum Option =

  | Some[Int]

  | None

fun unwrapOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      return v

    None =>

      return default

fun main() -> Int =

  unwrapOr(None, 5)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 5);

}

#[test]

fn enumClassFieldConstructAndDestructureRunsCorrectly() {

    // Interop check: a class with a field of an enum type, constructed with a

    // payload variant, then matched via the class field.

    let src = "\

enum Option =

  | Some[Int]

  | None

type Box =

  value: Option

  fun unwrap(default: Int) -> Int =

    match self.value

      Some(v) =>

        return v

      None =>

        return default

fun main() -> Int =

  b = Box(value: Some(42))

  b.unwrap(0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn tailMatchWithoutReturnRunsCorrectly() {

    let src = "\

fun bindExample(n: Int) -> Int =

  match n

    x =>

      x

fun main() -> Int =

  bindExample(5)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 5);

}

#[test]

fn tailIfWithoutReturnRunsCorrectly() {

    let src = "\

fun abs(n: Int) -> Int =

  if n < 0

    -n

  else

    n

fun main() -> Int =

  abs(-7)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn tailIfNestedInsideMatchArmWithoutReturnRunsCorrectly() {

    let src = "\

fun classify(n: Int) -> Int =

  match n

    0 =>

      1

    x =>

      if x < 0

        -1

      else

        2

fun main() -> Int =

  classify(-5)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), -1);

}

#[test]

fn tailMatchMixingReturnAndBareExprArmsRunsCorrectly() {

    let src = "\

fun describe(n: Int) -> Int =

  match n

    0 =>

      return 100

    x =>

      x * 2

fun main() -> Int =

  describe(21)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn tailEnumMatchWithoutReturnRunsCorrectly() {

    let src = "\

enum Option =

  | Some[Int]

  | None

fun unwrapOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      v

    None =>

      default

fun main() -> Int =

  unwrapOr(Some(9), 0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 9);

}

#[test]

fn tailIfWithoutElseIsAClearError() {

    let src = "\

fun bad(n: Int) -> Int =

  if n < 0

    return 1

";

    let source = parse(src);

    let err = compileSource(&source).expect_err("if without else in value position must be a clear error, not invalid wasm");

    assert!(err.contains("doesn't produce a return value"), "got: {}", err);

}

#[test]

fn tailMatchNonExhaustiveIsAClearError() {

    let src = "\

fun bad(n: Int) -> Int =

  match n

    0 =>

      1

";

    let source = parse(src);

    let err = compileSource(&source).expect_err("non-exhaustive match in value position must be a clear error, not invalid wasm");

    assert!(err.contains("doesn't produce a return value"), "got: {}", err);

}

#[test]

fn tailMatchArmEndingInNonValueStatementIsAClearError() {

    let src = "\

fun bad(n: Int) -> Int =

  match n

    x =>

      y = x

";

    let source = parse(src);

    let err = compileSource(&source).expect_err("a match arm ending in a non-value statement must be a clear error, not invalid wasm");

    assert!(err.contains("doesn't produce a return value"), "got: {}", err);

}

#[test]

fn genericClassSpecializedAtTwoTypesDoesNotAlias() {

    let src = "\

type Box[T] =

  value: T

  fun getIntValue() -> Int =

    self.value

fun useInt() -> Int =

  b = Box(value: 7)

  b.getIntValue()

fun main() -> Int =

  useInt()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn genericFunctionCalledAtMultipleConcreteTypesRunsCorrectly() {

    let src = "\

fun identity(value: T) -> T =

  value

fun main() -> Int =

  identity(5) + identity(37)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn genericMethodOnGenericClassRunsCorrectly() {

    let src = "\

type Box[T] =

  value: T

  fun getValue() -> Int =

    self.value

fun main() -> Int =

  b = Box(value: 9)

  b.getValue()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 9);

}

#[test]

fn transitivelyGenericCallChainRunsCorrectly() {

    let src = "\

fun identity(value: T) -> T =

  value

fun doubled(value: T) -> Int =

  identity(value) + identity(value)

fun main() -> Int =

  doubled(21)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn genericEnumSpecializedAndMatchedRunsCorrectly() {

    let src = "\

enum Option =

  | Some[T]

  | None

fun unwrapOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      v

    None =>

      default

fun main() -> Int =

  unwrapOr(Some(13), 0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 13);

}

#[test]

fn genericEnumMultipleInstantiationsCoexistAndRunCorrectly() {

    // `Str.length()` is not a real, working method in this codebase (no built-in

    // Str methods exist in codegen, and string-literal match patterns are an

    // explicit, documented "not yet supported" error — see

    // `matchStringPatternIsAClearError` above). So the `Some(v) => ...` arm

    // for the Str instantiation returns a fixed literal instead of deriving

    // anything from `v`'s content; the point of this test is that `Option$Str`

    // coexists with `Option$Int` and both run correctly, not string processing.

    let src = "\

enum Option =

  | Some[T]

  | None

fun unwrapIntOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      v

    None =>

      default

fun unwrapStrOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      4

    None =>

      default

fun main() -> Int =

  unwrapIntOr(Some(13), 0) + unwrapStrOr(Some(\"abcd\"), 0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 17);

}

#[test]

fn sameBareGenericEnumParamFunctionCalledMultipleTimesRunsCorrectly() {

    // Regression test: the same generic function taking a bare generic-enum-typed param,

    // called at the same concrete instantiation multiple times, must correctly specialize

    // and reuse that specialization. This tests that the mangling logic for `unwrapOr`

    // produces identical specialized code on both call sites, not aliased/incorrect code.

    let src = "\

enum Option =

  | Some[T]

  | None

fun unwrapOr(o: Option, default: Int) -> Int =

  match o

    Some(v) =>

      v

    None =>

      default

fun main() -> Int =

  unwrapOr(Some(5), 0) + unwrapOr(Some(37), 0)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 42);

}

#[test]

fn ordinaryFunctionWithBareGenericClassParamRunsCorrectly() {

    let src = "\

type Box[T] =

  value: T

  fun getBoxValue() -> Int =

    self.value

fun sumBox(b: Box) -> Int =

  b.getBoxValue()

fun main() -> Int =

  sumBox(Box(value: 11))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 11);

}

#[test]

fn wasmModuleWithATableElementValidatesAndCallIndirectWorks() {

    // Exercises WasmModule's new table/element support directly, independent of any

    // closure-compiling logic (which doesn't exist yet) — builds a tiny module by

    // hand: one function that returns 42, registered as table element 0, called via

    // `call_indirect` from `main` using a runtime-computed (not compile-time-constant)

    // table index, to prove the table/element wiring is real, not coincidentally

    // skipped by validation.

    let mut module = plum_wasm_codegen::WasmModule::new();

    let ret42_type = module.addType(&[], &[wasm_encoder::ValType::I64]);

    let ret42_idx = module.addFunction(ret42_type, &{

        let mut body = vec![0u8]; // 0 local-decl groups

        wasm_encoder::Instruction::I64Const(42).encode(&mut body);

        wasm_encoder::Instruction::End.encode(&mut body);

        body

    });

    let table_idx = module.addTableElement(ret42_idx);

    assert_eq!(table_idx, 0);

    let main_type = module.addType(&[], &[wasm_encoder::ValType::I64]);

    let main_idx = module.addFunction(main_type, &{

        let mut body = vec![0u8]; // 0 local-decl groups

        wasm_encoder::Instruction::I32Const(0).encode(&mut body); // table index operand

        wasm_encoder::Instruction::CallIndirect { type_index: ret42_type, table_index: 0 }.encode(&mut body);

        wasm_encoder::Instruction::End.encode(&mut body);

        body

    });

    module.addExport("main", wasm_encoder::ExportKind::Func, main_idx);

    let bytes = module.finish();

    let result = wasmparser::validate(&bytes);

    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());

    let engine = gcEngine();

    let wasm_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, &wasm_module, &[]).expect("module should instantiate");

    let main = instance.get_typed_func::<(), i64>(&mut store, "main").expect("main should have signature () -> i64");

    assert_eq!(main.call(&mut store, ()).expect("main should not trap"), 42);

}

#[test]

fn nonCapturingClosurePassedAndCalledRunsCorrectly() {

    let src = "\

fun each(cb: fn(Int) -> Int) -> Int =

  cb(5)

fun main() -> Int =

  each(|v| v)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 5);

}

#[test]

fn multiLineClosureCallArgumentWithClosingParenOnLastStatementLineRunsCorrectly() {

    // Was a documented gap: the external scanner never emitted a dedent for a

    // multi-line closure body immediately followed by `)` on the same line as the

    // body's last statement, so this shape didn't parse at all before.

    let src = "\

fun each(cb: fn(Int) -> Int) -> Int =

  cb(5)

fun main() -> Int =

  each(|v|

    x = v + 1

    x * 2)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 12);

}

#[test]

fn capturingClosureSnapshotsValueAtCreationTimeRunsCorrectly() {

    let src = "\

fun each(cb: fn(Int) -> Int) -> Int =

  cb(0)

fun useClosure() -> Int =

  x = 10

  cb = |v|

    x + v

  x = 999

  each(cb)

fun main() -> Int =

  useClosure()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    // The closure must see x==10 (its value when the closure was created), not 999

    // (its value when `each(cb)` is actually called) - proving snapshot-by-value

    // capture, not a live/shared reference.

    assert_eq!(runMain(&bytes), 10);

}

#[test]

fn closureAssignedThenCalledAtFloatTypeRunsCorrectly() {

    // Was a documented gap: a closure created via assignment (not passed directly as

    // a call argument) and later called at a concrete non-Int type could hit a wasm

    // runtime trap — the checker's own closure inference gives every param a fresh

    // TVar and never unifies it against how it's used in the body, so a genuinely

    // Float param silently defaulted to Int, producing a `call_indirect` signature

    // mismatch between the compiled closure body and its call site.

    let src = "\

fun eachF(cb: fn(Float) -> Float) -> Float =

  cb(0.0)

fun useClosure() -> Float =

  offset = 2.5

  cb = |v|

    offset + v

  eachF(cb)

fun main() -> Float =

  useClosure()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMainF64(&bytes), 2.5);

}

#[test]

fn closureAssignedThenCalledAtClassTypeRunsCorrectly() {

    let src = "\

type Cat =

  age: Int

fun eachCat(cb: fn(Cat) -> Int) -> Int =

  cb(Cat(age: 7))

fun useClosure() -> Int =

  cb = |c|

    c.age

  eachCat(cb)

fun main() -> Int =

  useClosure()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 7);

}

#[test]

fn closurePassedThroughAlreadyGenericHigherOrderFunctionRunsCorrectly() {

    let src = "\

fun identity(value: T) -> T =

  value

fun each(cb: fn(Int) -> Int) -> Int =

  cb(identity(7))

fun main() -> Int =

  each(|v| v * 2)

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 14);

}

#[test]

fn nestedClosureLiteralRunsCorrectly() {

    // Was a documented gap: a closure literal nested inside another closure's body

    // produced a clear compile error (the discovery pre-pass never recursed into a

    // closure's own body to find closures nested inside it). Here `inner` (nested

    // inside `outer`'s body) needs `offset` — a name from `useNested`'s scope, two

    // levels up from `inner` itself, and not referenced by `outer` directly — which

    // exercises the multi-level capture chain: `outer` must itself capture `offset`

    // purely because `inner` needs it, not because `outer` uses it.

    let src = "\

fun each(cb: fn(Int) -> Int) -> Int =

  cb(5)

fun useNested() -> Int =

  offset = 100

  outer = |v|

    inner = |w|

      w + offset

    inner(v)

  each(outer)

fun main() -> Int =

  useNested()

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 105);

}

#[test]

fn nestedClosureLiteralPassedDirectlyAsCallArgumentRunsCorrectly() {

    let src = "\

fun each(cb: fn(Int) -> Int) -> Int =

  cb(5)

fun main() -> Int =

  each(|v|

    each(|w| w + v))

";

    let source = parse(src);

    let bytes = compileSource(&source).expect("compile failed");

    assert_eq!(runMain(&bytes), 10);

}

#[test]

fn namedFunctionUsedAsAClosureTypedValueRunsCorrectly() {

    // A plain top-level named function (not a `|params| body` closure literal) used

    // wherever a `fn(...)`-typed value is expected — no closure literal involved at

    // the call site at all.

    let src = "\

fun double(x: Int) -> Int =

  x * 2