5d8ada1 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

5d8ada1 — Peter John 2026-07-19T21:40:57+05:30

feat(plum-wasm-codegen): class/method codegen, strings, match lowering

Files changed (4) hide show

Cargo.lock +1236 -24
plum-wasm-codegen/Cargo.toml +2 -0
plum-wasm-codegen/src/lib.rs +681 -200
plum-wasm-codegen/tests/codegen_tests.rs +258 -2

Cargo.lock CHANGED Viewed

@@ -2,13 +2,22 @@
 # It is not intended for manual editing.
 version = 4
+[[package]]
+name = "addr2line"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+dependencies = [
+ "gimli 0.31.1",
+]
 [[package]]
 name = "addr2line"
 version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
- "gimli",
+ "gimli 0.32.3",
 ]
 [[package]]
@@ -38,6 +47,12 @@ dependencies = [
  "memchr",
 ]
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -74,7 +89,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -85,7 +100,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -94,17 +109,43 @@ version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
+[[package]]
+name = "ar_archive_writer"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348"
+dependencies = [
+ "object 0.37.3",
+]
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+[[package]]
+name = "async-trait"
+version = "0.1.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae36dc4177970ef04fde5178d3e2429882def40e57a451f919c098f72baa6cec"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.0",
+]
 [[package]]
 name = "backtrace"
 version = "0.3.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
 dependencies = [
- "addr2line",
+ "addr2line 0.25.1",
  "cfg-if",
  "libc",
  "miniz_oxide",
- "object",
+ "object 0.37.3",
  "rustc-demangle",
  "windows-link",
 ]
@@ -118,17 +159,41 @@ dependencies = [
  "backtrace",
 ]
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 [[package]]
 name = "bitflags"
 version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+dependencies = [
+ "allocator-api2",
+]
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "cc"
@@ -137,6 +202,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c89588d05638b5b4594a3348a2d6c20277e43a7f5c5202b05cc56888475a47b8"
 dependencies = [
  "find-msvc-tools",
+ "jobserver",
+ "libc",
  "shlex",
 ]
@@ -186,12 +253,155 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.19",
+]
 [[package]]
 name = "colorchoice"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
+[[package]]
+name = "cpp_demangle"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2bb79cb74d735044c972aae58ed0aaa9a837e85b01106a54c39e42e97f62253"
+dependencies = [
+ "cfg-if",
+]
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+[[package]]
+name = "cranelift-bforest"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88c1d02b72b6c411c0a2e92b25ed791ad5d071184193c08a34aa0fdcdf000b72"
+dependencies = [
+ "cranelift-entity",
+]
+[[package]]
+name = "cranelift-bitset"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "720b93bd86ebbb23ebfb2db1ed44d54b2ecbdbb2d034d485bc64aa605ee787ab"
+dependencies = [
+ "serde",
+ "serde_derive",
+]
+[[package]]
+name = "cranelift-codegen"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aed3d2d9914d30b460eedd7fd507720203023997bef71452ce84873f9c93537c"
+dependencies = [
+ "bumpalo",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli 0.31.1",
+ "hashbrown 0.14.5",
+ "log",
+ "regalloc2",
+ "rustc-hash",
+ "serde",
+ "smallvec",
+ "target-lexicon",
+]
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "888c188d32263ec9e048873ff0b68c700933600d553f4412417916828be25f8e"
+dependencies = [
+ "cranelift-codegen-shared",
+]
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddd5f4114d04ce7e073dd74e2ad16541fc61970726fcc8b2d5644a154ee4127"
+[[package]]
+name = "cranelift-control"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92cc4c98d6a4256a1600d93ccd3536f3e77da9b4ca2c279de786ac22876e67d6"
+dependencies = [
+ "arbitrary",
+]
+[[package]]
+name = "cranelift-entity"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "760af4b5e051b5f82097a27274b917e3751736369fa73660513488248d27f23d"
+dependencies = [
+ "cranelift-bitset",
+ "serde",
+ "serde_derive",
+]
+[[package]]
+name = "cranelift-frontend"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0bf77ec0f470621655ec7539860b5c620d4f91326654ab21b075b83900f8831"
+dependencies = [
+ "cranelift-codegen",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+[[package]]
+name = "cranelift-isle"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b665d0a6932c421620be184f9fc7f7adaf1b0bc2fa77bb7ac5177c49abf645b"
+[[package]]
+name = "cranelift-native"
+version = "0.115.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb2e75d1bd43dfec10924798f15e6474f1dbf63b0024506551aa19394dbe72ab"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
 [[package]]
 name = "crossbeam-deque"
 version = "0.8.7"
@@ -217,18 +427,89 @@ version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+[[package]]
+name = "debugid"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef552e6f588e446098f6ba40d89ac146c8c7b64aade83c051ee00bb5d2bc18d"
+dependencies = [
+ "uuid",
+]
 [[package]]
 name = "diff"
 version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+[[package]]
+name = "directories-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
 [[package]]
 name = "either"
 version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -242,15 +523,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 [[package]]
 name = "futures"
 version = "0.3.33"
@@ -339,6 +632,71 @@ dependencies = [
  "slab",
 ]
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+[[package]]
+name = "fxprof-processed-profile"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27d12c0aed7f1e24276a241aadc4cb8ea9f83000f34bc062b7cc2d51e3b0fabd"
+dependencies = [
+ "bitflags",
+ "debugid",
+ "fxhash",
+ "serde",
+ "serde_json",
+]
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+]
+[[package]]
+name = "gimli"
+version = "0.31.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+dependencies = [
+ "fallible-iterator",
+ "indexmap",
+ "stable_deref_trait",
+]
 [[package]]
 name = "gimli"
 version = "0.32.3"
@@ -355,6 +713,16 @@ dependencies = [
  "serde",
 ]
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+ "serde",
+]
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
@@ -367,6 +735,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
 [[package]]
 name = "indexmap"
 version = "2.14.0"
@@ -400,12 +774,51 @@ dependencies = [
  "either",
 ]
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
 [[package]]
 name = "itoa"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+[[package]]
+name = "ittapi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b996fe614c41395cdaedf3cf408a9534851090959d90d54a535f675550b64b1"
+dependencies = [
+ "anyhow",
+ "ittapi-sys",
+ "log",
+]
+[[package]]
+name = "ittapi-sys"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f5385394064fa2c886205dba02598013ce83d3e92d33dbdc0c52fe0e7bf4fc"
+dependencies = [
+ "cc",
+]
+[[package]]
+name = "jobserver"
+version = "0.1.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3"
+dependencies = [
+ "getrandom 0.4.3",
+ "libc",
+]
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -422,6 +835,12 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c83bff1d572d6b9aeef67ddfc8448e4a3737909cb28e81f97c791b9018703e52"
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
 [[package]]
 name = "libc"
 version = "0.2.186"
@@ -429,23 +848,62 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 [[package]]
-name = "linux-raw-sys"
+name = "libm"
-version = "0.12.1"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 [[package]]
-name = "log"
+name = "libredox"
-version = "0.4.33"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c943259e342f1e06ff2da7a83eabdfe7f92ce10262688dbf1895ff0b3e6e4652"
+dependencies = [
+ "libc",
+]
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+[[package]]
+name = "log"
+version = "0.4.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
-[[package]]
+[[package]]
+name = "mach2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+dependencies = [
+ "libc",
+]
+[[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+[[package]]
+name = "memfd"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad38eb12aea514a0466ea40a80fd8cc83637065948eb4a426e4aa46261175227"
+dependencies = [
+ "rustix 1.1.4",
+]
 [[package]]
 name = "miette"
 version = "7.6.0"
@@ -485,6 +943,18 @@ dependencies = [
  "adler2",
 ]
+[[package]]
+name = "object"
+version = "0.36.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "memchr",
+]
 [[package]]
 name = "object"
 version = "0.37.3"
@@ -512,12 +982,24 @@ version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
 [[package]]
 name = "plum-checker"
 version = "0.1.0"
@@ -554,11 +1036,25 @@ dependencies = [
 name = "plum-wasm-codegen"
 version = "0.1.0"
 dependencies = [
+ "plum-checker",
  "plum-core",
  "tree-sitter",
  "tree-sitter-plum",
- "wasm-encoder",
+ "wasm-encoder 0.220.1",
+ "wasmparser 0.220.1",
- "wasmparser",
+ "wasmtime",
+]
+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "serde",
 ]
 [[package]]
@@ -589,6 +1085,27 @@ dependencies = [
  "unicode-ident",
 ]
+[[package]]
+name = "psm"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+[[package]]
+name = "pulley-interpreter"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8324e531de91a3c25021a30fb7862d39cc516b61fbb801176acb5ff279ea887b"
+dependencies = [
+ "cranelift-bitset",
+ "log",
+ "sptr",
+]
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -598,6 +1115,12 @@ dependencies = [
  "proc-macro2",
 ]
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -618,6 +1141,31 @@ dependencies = [
  "crossbeam-utils",
 ]
+[[package]]
+name = "redox_users"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 1.0.69",
+]
+[[package]]
+name = "regalloc2"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a"
+dependencies = [
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.15.5",
+ "log",
+ "rustc-hash",
+ "smallvec",
+]
 [[package]]
 name = "regex"
 version = "1.13.1"
@@ -653,6 +1201,25 @@ version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb"
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
 [[package]]
 name = "rustix"
 version = "1.1.4"
@@ -662,8 +1229,8 @@ dependencies = [
  "bitflags",
  "errno",
  "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.12.1",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -677,6 +1244,10 @@ name = "semver"
 version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
 [[package]]
 name = "serde"
@@ -722,6 +1293,26 @@ dependencies = [
  "zmij",
 ]
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -734,6 +1325,27 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+[[package]]
+name = "smallvec"
+version = "1.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+dependencies = [
+ "serde",
+]
+[[package]]
+name = "sptr"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a"
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 [[package]]
 name = "streaming-iterator"
 version = "0.1.9"
@@ -789,14 +1401,29 @@ dependencies = [
  "unicode-ident",
 ]
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
 [[package]]
 name = "terminal_size"
 version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
- "rustix",
+ "rustix 1.1.4",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 [[package]]
@@ -809,13 +1436,33 @@ dependencies = [
  "unicode-width 0.2.2",
 ]
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
 [[package]]
 name = "thiserror"
 version = "2.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09a43598840e33d5b0331f38c5e30d13bb11c11210a4b58f0d9b18a5a5eefcd9"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.19",
+]
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
 ]
 [[package]]
@@ -850,6 +1497,47 @@ dependencies = [
  "syn 2.0.119",
 ]
+[[package]]
+name = "toml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+[[package]]
+name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_write",
+ "winnow",
+]
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 [[package]]
 name = "topiary-core"
 version = "0.7.3"
@@ -857,7 +1545,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "89df094e19f103c5b8e120a1ffa30a6309daa10bef8d186e598a3df633e6a221"
 dependencies = [
  "futures",
- "itertools",
+ "itertools 0.11.0",
  "log",
  "miette",
  "pretty_assertions",
@@ -866,7 +1554,7 @@ dependencies = [
  "serde",
  "serde_json",
  "streaming-iterator",
- "thiserror",
+ "thiserror 2.0.19",
  "tokio",
  "topiary-tree-sitter-facade",
  "topiary-web-tree-sitter-sys",
@@ -929,6 +1617,12 @@ dependencies = [
  "tree-sitter-language",
 ]
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -953,18 +1647,40 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+[[package]]
+name = "uuid"
+version = "1.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf3923a6f5c4c6382e0b653c4117f48d631ea17f38ed86e2a828e6f7412f5239"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
 [[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.100"
@@ -1043,7 +1759,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e913f9242315ca39eff82aee0e19ee7a372155717ff0eb082c741e435ce25ed1"
 dependencies = [
  "leb128",
- "wasmparser",
+ "wasmparser 0.220.1",
+]
+[[package]]
+name = "wasm-encoder"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5"
+dependencies = [
+ "leb128",
+ "wasmparser 0.221.3",
+]
+[[package]]
+name = "wasm-encoder"
+version = "0.253.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59972d6cd272259de647b7c1f1912e45e289c75ffd4be04e10695507cd7e1b59"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.253.0",
 ]
 [[package]]
@@ -1060,6 +1796,306 @@ dependencies = [
  "serde",
 ]
+[[package]]
+name = "wasmparser"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+ "serde",
+]
+[[package]]
+name = "wasmparser"
+version = "0.253.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19db11f87d2486580e1e8b6f494c54df7e0566b87d0b599db843c24019667339"
+dependencies = [
+ "bitflags",
+ "indexmap",
+ "semver",
+]
+[[package]]
+name = "wasmprinter"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7343c42a97f2926c7819ff81b64012092ae954c5d83ddd30c9fcdefd97d0b283"
+dependencies = [
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.221.3",
+]
+[[package]]
+name = "wasmtime"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd30973c65eceb0f37dfcc430d83abd5eb24015fdfcab6912f52949287e04f0"
+dependencies = [
+ "addr2line 0.24.2",
+ "anyhow",
+ "async-trait",
+ "bitflags",
+ "bumpalo",
+ "cc",
+ "cfg-if",
+ "encoding_rs",
+ "fxprof-processed-profile",
+ "gimli 0.31.1",
+ "hashbrown 0.14.5",
+ "indexmap",
+ "ittapi",
+ "libc",
+ "libm",
+ "log",
+ "mach2",
+ "memfd",
+ "object 0.36.7",
+ "once_cell",
+ "paste",
+ "postcard",
+ "psm",
+ "pulley-interpreter",
+ "rayon",
+ "rustix 0.38.44",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "smallvec",
+ "sptr",
+ "target-lexicon",
+ "wasm-encoder 0.221.3",
+ "wasmparser 0.221.3",
+ "wasmtime-asm-macros",
+ "wasmtime-cache",
+ "wasmtime-component-macro",
+ "wasmtime-component-util",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+ "wasmtime-fiber",
+ "wasmtime-jit-debug",
+ "wasmtime-jit-icache-coherence",
+ "wasmtime-slab",
+ "wasmtime-versioned-export-macros",
+ "wasmtime-winch",
+ "wat",
+ "windows-sys 0.59.0",
+]
+[[package]]
+name = "wasmtime-asm-macros"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6c21dd30d1f3f93ee390ac1a7ec304ecdbfdab6390e1add41a1f52727b0992b"
+dependencies = [
+ "cfg-if",
+]
+[[package]]
+name = "wasmtime-cache"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cabd563cfbfe75c5bf514081f624ca8d18391a37520d8c794abce702474e688c"
+dependencies = [
+ "anyhow",
+ "base64",
+ "directories-next",
+ "log",
+ "postcard",
+ "rustix 0.38.44",
+ "serde",
+ "serde_derive",
+ "sha2",
+ "toml",
+ "windows-sys 0.59.0",
+ "zstd",
+]
+[[package]]
+name = "wasmtime-component-macro"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f948a6ef3119d52c9f12936970de28ddf3f9bea04bc65571f4a92d2e5ab38f4"
+dependencies = [
+ "anyhow",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "wasmtime-component-util",
+ "wasmtime-wit-bindgen",
+ "wit-parser",
+]
+[[package]]
+name = "wasmtime-component-util"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9275aa01ceaaa2fa6c0ecaa5267518d80b9d6e9ae7c7ea42f4c6e073e6a69ef"
+[[package]]
+name = "wasmtime-cranelift"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0701a44a323267aae4499672dae422b266cee3135a23b640972ec8c0e10a44a2"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cranelift-codegen",
+ "cranelift-control",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "gimli 0.31.1",
+ "itertools 0.12.1",
+ "log",
+ "object 0.36.7",
+ "smallvec",
+ "target-lexicon",
+ "thiserror 1.0.69",
+ "wasmparser 0.221.3",
+ "wasmtime-environ",
+ "wasmtime-versioned-export-macros",
+]
+[[package]]
+name = "wasmtime-environ"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "264c968c1b81d340355ece2be0bc31a10f567ccb6ce08512c3b7d10e26f3cbe5"
+dependencies = [
+ "anyhow",
+ "cpp_demangle",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli 0.31.1",
+ "indexmap",
+ "log",
+ "object 0.36.7",
+ "postcard",
+ "rustc-demangle",
+ "semver",
+ "serde",
+ "serde_derive",
+ "smallvec",
+ "target-lexicon",
+ "wasm-encoder 0.221.3",
+ "wasmparser 0.221.3",
+ "wasmprinter",
+ "wasmtime-component-util",
+]
+[[package]]
+name = "wasmtime-fiber"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78505221fd5bd7b07b4e1fa2804edea49dc231e626ad6861adc8f531812973e6"
+dependencies = [
+ "anyhow",
+ "cc",
+ "cfg-if",
+ "rustix 0.38.44",
+ "wasmtime-asm-macros",
+ "wasmtime-versioned-export-macros",
+ "windows-sys 0.59.0",
+]
+[[package]]
+name = "wasmtime-jit-debug"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cec0a8e5620ae71bfcaaec78e3076be5b6ebf869f4e6191925d73242224a915"
+dependencies = [
+ "object 0.36.7",
+ "rustix 0.38.44",
+ "wasmtime-versioned-export-macros",
+]
+[[package]]
+name = "wasmtime-jit-icache-coherence"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bedb677ca1b549d98f95e9e1f9251b460090d99a2c196a0614228c064bf2e59"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "libc",
+ "windows-sys 0.59.0",
+]
+[[package]]
+name = "wasmtime-slab"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "564905638c132c275d365c1fa074f0b499790568f43148d29de84ccecfb5cb31"
+[[package]]
+name = "wasmtime-versioned-export-macros"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e91092e6cf77390eeccee273846a9327f3e8f91c3c6280f60f37809f0e62d29"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+]
+[[package]]
+name = "wasmtime-winch"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b111d909dc604c741bd8ac2f4af373eaa5c68c34b5717271bcb687688212cef8"
+dependencies = [
+ "anyhow",
+ "cranelift-codegen",
+ "gimli 0.31.1",
+ "object 0.36.7",
+ "target-lexicon",
+ "wasmparser 0.221.3",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+ "winch-codegen",
+]
+[[package]]
+name = "wasmtime-wit-bindgen"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f38f7a5eb2f06f53fe943e7fb8bf4197f7cf279f1bc52c0ce56e9d3ffd750a4"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "wit-parser",
+]
+[[package]]
+name = "wast"
+version = "253.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3264542f8965c5d84fb1085d924bfba9a6314bb228eff13a2de14d7627664d0"
+dependencies = [
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width 0.2.2",
+ "wasm-encoder 0.253.0",
+]
+[[package]]
+name = "wat"
+version = "1.253.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bfc5ce906144200c972ec617470aa35bd847472e170b26dde3e80541c674055"
+dependencies = [
+ "wast",
+]
 [[package]]
 name = "web-sys"
 version = "0.3.77"
@@ -1070,12 +2106,69 @@ dependencies = [
  "wasm-bindgen",
 ]
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+[[package]]
+name = "winch-codegen"
+version = "28.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6232f40a795be2ce10fc761ed3b403825126a60d12491ac556ea104a932fd18a"
+dependencies = [
+ "anyhow",
+ "cranelift-codegen",
+ "gimli 0.31.1",
+ "regalloc2",
+ "smallvec",
+ "target-lexicon",
+ "wasmparser 0.221.3",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+]
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1085,6 +2178,97 @@ dependencies = [
  "windows-link",
 ]
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+dependencies = [
+ "memchr",
+]
+[[package]]
+name = "wit-parser"
+version = "0.221.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "896112579ed56b4a538b07a3d16e562d101ff6265c46b515ce0c701eef16b2ac"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.221.3",
+]
 [[package]]
 name = "yansi"
 version = "1.0.1"
@@ -1116,3 +2300,31 @@ name = "zmij"
 version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]

plum-wasm-codegen/Cargo.toml CHANGED Viewed

@@ -6,8 +6,10 @@ edition = "2021"
 [dependencies]
 wasm-encoder = "0.220"
 plum-core = { path = "../plum-core" }
+plum-checker = { path = "../plum-checker" }
 [dev-dependencies]
 wasmparser = "0.220"
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
+wasmtime = "28"

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -1,6 +1,15 @@
 use wasm_encoder::*;
+use std::cell::RefCell;
 use std::collections::HashMap;
 use plum_core::ast;
+use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
+use plum_checker::{ClassEnv, MethodEnv, EnumVariants};
+/// Bump-allocated heap for class instances starts at the second 64KiB page so it can
+/// never collide with the (small, compile-time-sized) string literal data area below it.
+const HEAP_BASE: u32 = 65536;
+/// String literal data (length-prefixed UTF-8 blobs) is laid out from here upward.
+const STRING_BASE: u32 = 8;
 pub struct WasmModule {
     types: Vec<FuncType>,
@@ -172,31 +181,57 @@ pub struct FuncSig {
     pub ret: Option<ValType>,
 }
+/// Global, read-only lookup tables shared by every function body being compiled.
 pub struct CompileCtx {
-    pub module: WasmModule,
     pub func_ids: HashMap<String, u32>,
     pub func_sigs: HashMap<String, FuncSig>,
+    pub classes: ClassEnv,
+    pub methods: MethodEnv,
-    pub current_locals: HashMap<String, u32>,
+    pub enum_variants: EnumVariants,
-    pub label_count: u32,
+    pub global_env: TypeEnv,
-    pub bump_offset: u32,
+    pub bump_global: u32,
 }
+/// Per-module state that accumulates as function bodies are compiled: the running
+/// offset for placing string literal bytes, and the resulting data segments.
-impl CompileCtx {
+struct ModuleState {
-    pub fn new() -> Self {
-        Self {
-            module: WasmModule::new(),
-            func_ids: HashMap::new(),
-            func_sigs: HashMap::new(),
-            current_locals: HashMap::new(),
-            label_count: 0,
-            bump_offset: 0,
+    next_string_offset: u32,
+    data_segments: Vec<(u32, Vec<u8>)>,
-        }
+}
+struct LocalCtx<'a> {
+    locals: HashMap<String, u32>,
+    /// First local index reserved for `ClassCall` scratch temporaries.
+    classcall_scratch_base: u32,
+    /// `ClassCall` expr identity (pointer address) -> scratch slot offset.
+    classcall_scratch: HashMap<usize, u32>,
+    /// First local index reserved for `match` subject scratch temporaries.
+    match_scratch_base: u32,
+    /// `Match` stmt identity (pointer address) -> scratch slot offset.
+    match_scratch_index: HashMap<usize, u32>,
+    func_ids: &'a HashMap<String, u32>,
+    func_sigs: &'a HashMap<String, FuncSig>,
+    classes: &'a ClassEnv,
+    methods: &'a MethodEnv,
+    enum_variants: &'a EnumVariants,
+    /// Tracks each binding's inferred type as compilation proceeds through
+    /// statements in order, mirroring `plum-checker`'s own env evolution — needed
+    /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
+    type_env: RefCell<TypeEnv>,
+    bump_global: u32,
+}
+fn fn_key(f: &ast::Fn) -> String {
+    match &f.type_param {
+        Some(recv) => format!("{}::{}", recv, f.name),
+        None => f.name.clone(),
     }
 }
+fn param_type_name(pt: &ast::ParamType) -> &str {
-impl Default for CompileCtx {
+    match pt {
-    fn default() -> Self {
+        ast::ParamType::Type(t) => t.name.as_str(),
-        Self::new()
+        ast::ParamType::Variadic(t) => t.name.as_str(),
     }
 }
@@ -207,7 +242,16 @@ fn ast_type_to_wasm(name: &str) -> Option<ValType> {
         "Bool" => Some(ValType::I32),
         "Str" => Some(ValType::I32),
         "Unit" => None,
+        _ => Some(ValType::I32), // class instance / unmodeled type: pointer
+    }
+}
+fn plum_type_to_valtype(t: &PlumType) -> ValType {
+    match t {
-        _ => Some(ValType::I64),
+        PlumType::TInt => ValType::I64,
+        PlumType::TFloat => ValType::F64,
+        PlumType::TBool | PlumType::TStr | PlumType::TNamed(_) => ValType::I32,
+        PlumType::TVar(_) | PlumType::TUnit | PlumType::TFun(_, _) => ValType::I64,
     }
 }
@@ -231,156 +275,335 @@ fn encode_leb128_u32(mut val: u32) -> Vec<u8> {
     bytes
 }
+fn check_ctx_of<'a>(ctx_classes: &'a ClassEnv, ctx_methods: &'a MethodEnv, ctx_enum_variants: &'a EnumVariants) -> plum_checker::CheckCtx<'a> {
+    plum_checker::CheckCtx { classes: ctx_classes, methods: ctx_methods, enum_variants: ctx_enum_variants }
+}
+/// Infers an expression's type using the function's current (mutable, evolving) type
+/// environment. Defaults to `TInt` if inference fails — codegen assumes the source was
+/// already accepted by `plum_checker::check_source`, so a failure here would indicate
+/// codegen is being driven directly on unchecked input (as some tests do).
+fn infer_local_type(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
+    let env = ctx.type_env.borrow();
+    let cctx = check_ctx_of(ctx.classes, ctx.methods, ctx.enum_variants);
+    plum_checker::infer_expr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
+}
 pub fn compile_source(source: &ast::Source) -> Result<Vec<u8>, String> {
+    let (global_env, classes, methods, enum_variants) = plum_checker::build_global_tables(source);
-    let mut ctx = CompileCtx::new();
+    let mut module = WasmModule::new();
+    module.add_memory(2, None);
+    let mut bump_init = Vec::new();
+    Instruction::I32Const(HEAP_BASE as i32).encode(&mut bump_init);
+    let bump_global = module.add_global(ValType::I32, true, &bump_init);
+    let mut func_ids: HashMap<String, u32> = HashMap::new();
+    let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
-    // First pass: register all function type signatures and allocate function slots
+    // Register every function AND method signature up front (methods get an implicit
+    // leading `self: pointer` param and are keyed as "Receiver::method").
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
+            let mut param_types: Vec<ValType> = Vec::new();
             if f.type_param.is_some() {
-                continue; // skip method impls in v1
+                param_types.push(ValType::I32);
-            }
+            }
-            let param_types: Vec<ValType> = f
-                .params
-                .iter()
-                .map(|p| {
-                    let name = match &p.ty {
+            for p in &f.params {
-                        ast::ParamType::Type(t) => t.name.as_str(),
-                        ast::ParamType::Variadic(t) => t.name.as_str(),
-                    };
-                    ast_type_to_wasm(name).unwrap_or(ValType::I64)
+                param_types.push(ast_type_to_wasm(param_type_name(&p.ty)).unwrap_or(ValType::I32));
-                })
+            }
-                .collect();
             let ret = ret_type_to_wasm(f.returns.as_ref());
             let results_vec: Vec<ValType> = ret.into_iter().collect();
-            let type_idx = ctx.module.add_type(&param_types, &results_vec);
+            let type_idx = module.add_type(&param_types, &results_vec);
-            let func_idx = ctx.module.add_function(type_idx, &[]);
+            let func_idx = module.add_function(type_idx, &[]);
+            let key = fn_key(f);
-            ctx.func_ids.insert(f.name.clone(), func_idx);
+            func_ids.insert(key.clone(), func_idx);
-            ctx.func_sigs.insert(f.name.clone(), FuncSig { params: param_types, ret });
+            func_sigs.insert(key, FuncSig { params: param_types, ret });
         }
     }
-    // Second pass: compile each function body
+    let ctx = CompileCtx { func_ids, func_sigs, classes, methods, enum_variants, global_env, bump_global };
-    let fns: Vec<ast::Fn> = source
+    let fns: Vec<&ast::Fn> = source.items.iter().filter_map(|item| match item {
-        .items
-        .iter()
-        .filter_map(|item| {
-            if let ast::Item::Fn(f) = item {
+        ast::Item::Fn(f) => Some(f),
-                if f.type_param.is_none() {
-                    Some(f.clone())
+        _ => None,
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        })
-        .collect();
+    }).collect();
+    let mut state = ModuleState { next_string_offset: STRING_BASE, data_segments: Vec::new() };
     let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();
     for f in &fns {
-        let body = compile_fn_body(f, &ctx)?;
+        let body = compile_fn_body(f, &ctx, &mut state)?;
-        compiled_bodies.push((f.name.clone(), body));
+        compiled_bodies.push((fn_key(f), body));
+    }
+    // Patch compiled bodies back into their pre-registered function slots.
+    for (name, body) in &compiled_bodies {
+        let idx = *ctx.func_ids.get(name).expect("function was registered in the first pass");
+        let slot = (idx - module.func_import_count) as usize;
+        module.functions[slot].1 = body.clone();
     }
-    // Patch bodies into the module
-    for (i, (_, body)) in compiled_bodies.iter().enumerate() {
+    for (offset, bytes) in &state.data_segments {
-        ctx.module.functions[i].1 = body.clone();
+        module.add_data_segment(*offset, bytes);
     }
-    // Export only main
     if let Some(&main_idx) = ctx.func_ids.get("main") {
-        ctx.module.add_export("main", ExportKind::Func, main_idx);
+        module.add_export("main", ExportKind::Func, main_idx);
     }
-    Ok(ctx.module.finish())
+    Ok(module.finish())
 }
+/// Walks a function body once to determine: (1) every locally-assigned/bound name and
+/// its inferred type, (2) how many `ClassCall` scratch temporaries it needs, and (3)
+/// the subject type for every `match` statement (for its own scratch temporary).
+struct Collector<'a> {
+    env: TypeEnv,
+    cctx: plum_checker::CheckCtx<'a>,
+    named: Vec<(String, PlumType)>,
-fn collect_local_names(body: &ast::FnBody) -> Vec<String> {
+    named_set: std::collections::HashSet<String>,
-    let mut names = Vec::new();
-    if let ast::FnBody::Block(block) = body {
-        collect_block_locals(block, &mut names);
+    classcall_scratch: HashMap<usize, u32>,
-    }
+    match_scratch: HashMap<usize, PlumType>,
-    names
+    next_classcall_slot: u32,
 }
+impl<'a> Collector<'a> {
-fn collect_block_locals(block: &ast::Block, names: &mut Vec<String>) {
+    fn bind(&mut self, name: &str, ty: PlumType) {
-    for stmt in &block.stmts {
-        collect_stmt_locals(stmt, names);
+        if self.named_set.insert(name.to_string()) {
+            self.named.push((name.to_string(), ty.clone()));
+        }
+        self.env.insert(name.to_string(), TypeScheme::mono(ty));
     }
-}
+    fn walk_block(&mut self, block: &ast::Block) {
+        for s in &block.stmts {
+            self.walk_stmt(s);
+        }
+    }
-fn collect_stmt_locals(stmt: &ast::Stmt, names: &mut Vec<String>) {
+    fn walk_stmt(&mut self, stmt: &ast::Stmt) {
-    match stmt {
+        match stmt {
-        ast::Stmt::Assign(a) => {
+            ast::Stmt::Assign(a) => {
+                for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                    self.walk_expr(value);
+                    let ty = plum_checker::infer_expr(value, &self.env, &self.cctx).unwrap_or(PlumType::TInt);
-            for t in &a.targets {
+                    self.bind(target, ty);
-                if !names.contains(t) {
-                    names.push(t.clone());
                 }
             }
+            ast::Stmt::Return(Some(e)) => self.walk_expr(e),
+            ast::Stmt::Return(None) => {}
+            ast::Stmt::If(i) => {
+                self.walk_expr(&i.condition);
+                self.walk_block(&i.body);
+                for ei in &i.else_ifs {
+                    self.walk_expr(&ei.condition);
+                    self.walk_block(&ei.body);
-        }
+                }
-        ast::Stmt::If(i) => {
-            collect_block_locals(&i.body, names);
-            for ei in &i.else_ifs {
+                if let Some(e) = &i.else_ {
-                collect_block_locals(&ei.body, names);
+                    self.walk_block(e);
+                }
             }
+            ast::Stmt::While(w) => {
+                self.walk_expr(&w.condition);
+                self.walk_block(&w.body);
+            }
+            ast::Stmt::For(f) => {
-            if let Some(e) = &i.else_ {
+                self.walk_expr(&f.iter);
+                for v in &f.vars {
+                    self.bind(v, PlumType::TInt);
+                }
-                collect_block_locals(e, names);
+                self.walk_block(&f.body);
             }
+            ast::Stmt::Expr(e) => self.walk_expr(e),
+            ast::Stmt::Assert(e) => self.walk_expr(e),
+            ast::Stmt::Match(m) => {
+                let subject_ty = if m.subjects.len() == 1 {
+                    self.walk_expr(&m.subjects[0]);
+                    plum_checker::infer_expr(&m.subjects[0], &self.env, &self.cctx).unwrap_or(PlumType::TInt)
+                } else {
+                    for s in &m.subjects {
+                        self.walk_expr(s);
+                    }
+                    PlumType::TInt
+                };
+                self.match_scratch.insert(m as *const ast::Match as usize, subject_ty.clone());
+                for case in &m.cases {
+                    let saved = self.env.clone();
+                    if m.subjects.len() == 1 {
+                        if let Some(ast::CasePattern::Name(n)) = case.patterns.first() {
+                            let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                                && self.cctx.enum_variants.contains_key(n);
+                            if !is_variant {
+                                self.bind(n, subject_ty.clone());
+                            }
+                        }
+                    }
+                    self.walk_block(&case.body);
+                    self.env = saved;
+                }
+            }
+            ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
         }
+    }
+    fn walk_expr(&mut self, expr: &ast::Expr) {
+        match expr {
+            ast::Expr::ClassCall(call) => {
+                let idx = self.next_classcall_slot;
+                self.next_classcall_slot += 1;
-        ast::Stmt::While(w) => collect_block_locals(&w.body, names),
+                self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
+                for fa in &call.fields {
+                    self.walk_expr(&fa.value);
+                }
+            }
+            ast::Expr::Binary(b) => {
+                self.walk_expr(&b.left);
+                self.walk_expr(&b.right);
+            }
-        ast::Stmt::For(f) => {
+            ast::Expr::Bool(b) => {
+                self.walk_expr(&b.left);
+                self.walk_expr(&b.right);
+            }
+            ast::Expr::Compare(c) => {
+                self.walk_expr(&c.left);
+                self.walk_expr(&c.right);
+            }
+            ast::Expr::Not(inner) => self.walk_expr(inner),
+            ast::Expr::Unary(u) => self.walk_expr(&u.operand),
+            ast::Expr::Paren(inner) => self.walk_expr(inner),
+            ast::Expr::Ternary(t) => {
+                self.walk_expr(&t.condition);
+                self.walk_expr(&t.then);
+                self.walk_expr(&t.else_);
+            }
+            ast::Expr::FnCall(call) => {
-            for v in &f.vars {
+                for arg in &call.args {
+                    self.walk_arg(arg);
+                }
+            }
+            ast::Expr::Attribute(a) => {
+                self.walk_expr(&a.object);
+                if let ast::AttrKind::Method(call) = &a.attr {
-                if !names.contains(v) {
+                    for arg in &call.args {
-                    names.push(v.clone());
+                        self.walk_arg(arg);
+                    }
                 }
             }
+            ast::Expr::Int(_)
+            | ast::Expr::Float(_)
+            | ast::Expr::String(_)
+            | ast::Expr::Self_
+            | ast::Expr::Var(_)
+            | ast::Expr::TypeName(_) => {}
+        }
+    }
+    fn walk_arg(&mut self, arg: &ast::Arg) {
+        match arg {
-            collect_block_locals(&f.body, names);
+            ast::Arg::Positional(e) => self.walk_expr(e),
+            ast::Arg::Keyword { value, .. } => self.walk_expr(value),
+            ast::Arg::Pair { value, .. } => self.walk_expr(value),
         }
-        _ => {}
     }
 }
-fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx) -> Result<Vec<u8>, String> {
+fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
-    let param_count = f.params.len() as u32;
-    // Collect extra (non-param) local variable names declared in the body
-    let extra_locals = collect_local_names(&f.body);
-    let extra_count = extra_locals.len() as u32;
+    let mut base_env = ctx.global_env.clone();
+    if let Some(recv) = &f.type_param {
+        base_env.insert("self".to_string(), TypeScheme::mono(PlumType::TNamed(recv.clone())));
+    }
+    for p in &f.params {
+        let ty = match &p.ty {
+            ast::ParamType::Type(t) => plum_checker::plum_type_from_ast(t),
+            ast::ParamType::Variadic(t) => plum_checker::plum_type_from_ast(t),
+        };
+        base_env.insert(p.name.clone(), TypeScheme::mono(ty));
+    }
+    let mut collector = Collector {
+        env: base_env.clone(),
-    // Encode local declarations: group count, then each group as (count, type)
+        cctx: check_ctx_of(&ctx.classes, &ctx.methods, &ctx.enum_variants),
+        named: Vec::new(),
+        named_set: Default::default(),
+        classcall_scratch: HashMap::new(),
+        match_scratch: HashMap::new(),
-    if extra_count > 0 {
+        next_classcall_slot: 0,
-        body.extend(encode_leb128_u32(1)); // 1 group
-        body.extend(encode_leb128_u32(extra_count));
+    };
-        ValType::I64.encode(&mut body);
+    if let ast::FnBody::Block(block) = &f.body {
-    } else {
-        body.push(0); // 0 groups
+        collector.walk_block(block);
     }
-    // Build locals map: params first, then extra locals
+    // ---- assign local indices: [self?][params][named...][classcall scratch...][match scratch...] ----
     let mut locals: HashMap<String, u32> = HashMap::new();
+    let mut groups: Vec<ValType> = Vec::new();
+    let mut idx = 0u32;
-    for (i, p) in f.params.iter().enumerate() {
+    if f.type_param.is_some() {
+        locals.insert("self".to_string(), idx);
+        idx += 1;
+    }
+    for p in &f.params {
-        locals.insert(p.name.clone(), i as u32);
+        locals.insert(p.name.clone(), idx);
+        idx += 1;
+    }
+    for (name, ty) in &collector.named {
+        let vt = plum_type_to_valtype(ty);
+        locals.insert(name.clone(), idx);
+        groups.push(vt);
+        idx += 1;
+    }
+    let classcall_scratch_base = idx;
+    let classcall_count = collector.classcall_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    for _ in 0..classcall_count {
+        groups.push(ValType::I32);
+        idx += 1;
+    }
+    let match_scratch_base = idx;
+    let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
+    for (ptr, ty) in collector.match_scratch.iter() {
+        match_scratch_index.insert(*ptr, idx - match_scratch_base);
+        groups.push(plum_type_to_valtype(ty));
+        idx += 1;
     }
-    for (i, name) in extra_locals.iter().enumerate() {
+    if groups.is_empty() {
+        body.push(0);
+    } else {
-        locals.insert(name.clone(), param_count + i as u32);
+        body.extend(encode_leb128_u32(groups.len() as u32));
+        for g in &groups {
+            body.extend(encode_leb128_u32(1));
+            g.encode(&mut body);
+        }
     }
     let local_ctx = LocalCtx {
         locals,
+        classcall_scratch_base,
+        classcall_scratch: collector.classcall_scratch,
+        match_scratch_base,
+        match_scratch_index,
         func_ids: &ctx.func_ids,
         func_sigs: &ctx.func_sigs,
+        classes: &ctx.classes,
+        methods: &ctx.methods,
+        enum_variants: &ctx.enum_variants,
+        type_env: RefCell::new(base_env),
+        bump_global: ctx.bump_global,
     };
     let has_return_value = f.returns.as_ref().map(|r| r.name != "Unit").unwrap_or(false);
     match &f.body {
         ast::FnBody::Expr(e) => {
-            compile_expr(e, &mut body, &local_ctx)?;
+            compile_expr(e, &mut body, &local_ctx, state)?;
         }
         ast::FnBody::Block(block) => {
-            compile_block_as_fn_body(block, &mut body, &local_ctx, has_return_value)?;
+            compile_block_as_fn_body(block, &mut body, &local_ctx, state, has_return_value)?;
         }
     }
@@ -388,89 +611,93 @@ fn compile_fn_body(f: &ast::Fn, ctx: &CompileCtx) -> Result<Vec<u8>, String> {
     Ok(body)
 }
-struct LocalCtx<'a> {
-    locals: HashMap<String, u32>,
-    func_ids: &'a HashMap<String, u32>,
-    func_sigs: &'a HashMap<String, FuncSig>,
-}
-fn compile_block(block: &ast::Block, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_block(block: &ast::Block, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     for stmt in &block.stmts {
-        compile_stmt(stmt, body, ctx)?;
+        compile_stmt(stmt, body, ctx, state)?;
     }
     Ok(())
 }
-/// Compile a block that is the body of a function. If the function returns a value
+/// Compiles a block that is the body of a function. If the function returns a value
 /// and the last statement is an expression, that expression's value is left on the
 /// stack instead of being dropped.
 fn compile_block_as_fn_body(
     block: &ast::Block,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
+    state: &mut ModuleState,
     has_return_value: bool,
 ) -> Result<(), String> {
     let stmts = &block.stmts;
     if has_return_value {
         if let Some((last, rest)) = stmts.split_last() {
             for stmt in rest {
-                compile_stmt(stmt, body, ctx)?;
+                compile_stmt(stmt, body, ctx, state)?;
             }
-            // Last statement: if it's an Expr, leave its value on stack
             match last {
                 ast::Stmt::Expr(e) => {
-                    compile_expr(e, body, ctx)?;
+                    compile_expr(e, body, ctx, state)?;
                     // do NOT drop — this is the return value
                 }
+                ast::Stmt::Match(m) => {
+                    compile_match(m, body, ctx, state)?;
+                    // Every arm of a tail-position match must itself `return`; if a
+                    // non-exhaustive match falls through, trap rather than continue
+                    // with the required-but-never-produced result value missing.
+                    // This also satisfies wasm validation, which requires a value at
+                    // the function's `end` regardless of whether every branch inside
+                    // the match's (BlockType::Empty) if/else chain already returned.
+                    Instruction::Unreachable.encode(body);
+                }
                 _ => {
-                    compile_stmt(last, body, ctx)?;
+                    compile_stmt(last, body, ctx, state)?;
                 }
             }
             return Ok(());
         }
     }
     for stmt in stmts {
-        compile_stmt(stmt, body, ctx)?;
+        compile_stmt(stmt, body, ctx, state)?;
     }
     Ok(())
 }
-fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     match stmt {
         ast::Stmt::Assign(a) => {
             for (target, value) in a.targets.iter().zip(a.values.iter()) {
+                let vty = infer_local_type(value, ctx);
-                compile_expr(value, body, ctx)?;
+                compile_expr(value, body, ctx, state)?;
-                let idx = *ctx
+                let idx = ctx
                     .locals
                     .get(target)
+                    .copied()
                     .ok_or_else(|| format!("undeclared local '{}'", target))?;
                 Instruction::LocalSet(idx).encode(body);
+                ctx.type_env.borrow_mut().insert(target.clone(), TypeScheme::mono(vty));
             }
         }
         ast::Stmt::Return(Some(e)) => {
-            compile_expr(e, body, ctx)?;
+            compile_expr(e, body, ctx, state)?;
             Instruction::Return.encode(body);
         }
         ast::Stmt::Return(None) => {
             Instruction::Return.encode(body);
         }
         ast::Stmt::If(if_) => {
-            compile_expr(&if_.condition, body, ctx)?;
+            compile_expr(&if_.condition, body, ctx, state)?;
-            // Condition is i64 (Bool is I32 but comparison results in I32)
-            // Convert to i32 for if: if condition came from compare ops it's already i32
-            // Use I32WrapI64 if needed — but compare ops return i32 already
             Instruction::If(BlockType::Empty).encode(body);
-            compile_block(&if_.body, body, ctx)?;
+            compile_block(&if_.body, body, ctx, state)?;
             if !if_.else_ifs.is_empty() || if_.else_.is_some() {
                 Instruction::Else.encode(body);
                 for ei in &if_.else_ifs {
-                    compile_expr(&ei.condition, body, ctx)?;
+                    compile_expr(&ei.condition, body, ctx, state)?;
                     Instruction::If(BlockType::Empty).encode(body);
-                    compile_block(&ei.body, body, ctx)?;
+                    compile_block(&ei.body, body, ctx, state)?;
                     Instruction::Else.encode(body);
                 }
                 if let Some(else_block) = &if_.else_ {
-                    compile_block(else_block, body, ctx)?;
+                    compile_block(else_block, body, ctx, state)?;
                 }
                 for _ in &if_.else_ifs {
                     Instruction::End.encode(body);
@@ -479,13 +706,12 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::End.encode(body);
         }
         ast::Stmt::While(w) => {
-            // block { loop { cond; i32.eqz; br_if 1; body; br 0 } }
             Instruction::Block(BlockType::Empty).encode(body);
             Instruction::Loop(BlockType::Empty).encode(body);
-            compile_expr(&w.condition, body, ctx)?;
+            compile_expr(&w.condition, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
             Instruction::BrIf(1).encode(body);
-            compile_block(&w.body, body, ctx)?;
+            compile_block(&w.body, body, ctx, state)?;
             Instruction::Br(0).encode(body);
             Instruction::End.encode(body);
             Instruction::End.encode(body);
@@ -494,19 +720,21 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             if let ast::Expr::Binary(b) = &f.iter {
                 if matches!(b.op, ast::BinOp::Range) && f.vars.len() == 1 {
                     let var_name = &f.vars[0];
-                    let var_idx = *ctx
+                    let var_idx = ctx
                         .locals
                         .get(var_name)
+                        .copied()
                         .ok_or_else(|| format!("undeclared loop var '{}'", var_name))?;
+                    ctx.type_env.borrow_mut().insert(var_name.clone(), TypeScheme::mono(PlumType::TInt));
-                    compile_expr(&b.left, body, ctx)?;
+                    compile_expr(&b.left, body, ctx, state)?;
                     Instruction::LocalSet(var_idx).encode(body);
                     Instruction::Block(BlockType::Empty).encode(body);
                     Instruction::Loop(BlockType::Empty).encode(body);
                     Instruction::LocalGet(var_idx).encode(body);
-                    compile_expr(&b.right, body, ctx)?;
+                    compile_expr(&b.right, body, ctx, state)?;
                     Instruction::I64GeS.encode(body);
                     Instruction::BrIf(1).encode(body);
-                    compile_block(&f.body, body, ctx)?;
+                    compile_block(&f.body, body, ctx, state)?;
                     Instruction::LocalGet(var_idx).encode(body);
                     Instruction::I64Const(1).encode(body);
                     Instruction::I64Add.encode(body);
@@ -517,12 +745,12 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                     return Ok(());
                 }
             }
-            compile_expr(&f.iter, body, ctx)?;
+            compile_expr(&f.iter, body, ctx, state)?;
             Instruction::Drop.encode(body);
         }
         ast::Stmt::Expr(e) => {
             let has_result = expr_has_result(e, ctx);
-            compile_expr(e, body, ctx)?;
+            compile_expr(e, body, ctx, state)?;
             if has_result {
                 Instruction::Drop.encode(body);
             }
@@ -533,7 +761,10 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
         ast::Stmt::Continue => {
             Instruction::Br(0).encode(body);
         }
+        ast::Stmt::Match(m) => {
+            compile_match(m, body, ctx, state)?;
+        }
-        ast::Stmt::Assert(_) | ast::Stmt::Match(_) | ast::Stmt::Todo => {}
+        ast::Stmt::Assert(_) | ast::Stmt::Todo => {}
     }
     Ok(())
 }
@@ -541,14 +772,139 @@ fn compile_stmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
 /// Returns true if the expression leaves a value on the wasm stack.
 fn expr_has_result(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
     match expr {
+        ast::Expr::FnCall(call) => ctx.func_sigs.get(&call.name).map(|s| s.ret.is_some()).unwrap_or(true),
+        ast::Expr::Attribute(attr) => match &attr.attr {
-        ast::Expr::FnCall(call) => {
+            ast::AttrKind::Method(call) => {
+                if let PlumType::TNamed(class_name) = infer_local_type(&attr.object, ctx) {
+                    let key = format!("{}::{}", class_name, call.name);
-            ctx.func_sigs.get(&call.name).map(|s| s.ret.is_some()).unwrap_or(true)
+                    ctx.func_sigs.get(&key).map(|s| s.ret.is_some()).unwrap_or(true)
+                } else {
+                    true
-        }
+                }
+            }
+            ast::AttrKind::Field(_) => true,
+        },
         _ => true,
     }
 }
+fn compile_match(m: &ast::Match, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
+    if m.subjects.len() != 1 {
+        return Err("codegen: multi-subject match is not yet supported".to_string());
+    }
+    let subject = &m.subjects[0];
+    let subject_ty = infer_local_type(subject, ctx);
+    let subject_vt = plum_type_to_valtype(&subject_ty);
+    let key = m as *const ast::Match as usize;
+    let slot = *ctx
+        .match_scratch_index
+        .get(&key)
+        .ok_or_else(|| "internal codegen error: missing match scratch slot".to_string())?;
+    let scratch_local = ctx.match_scratch_base + slot;
+    compile_expr(subject, body, ctx, state)?;
+    Instruction::LocalSet(scratch_local).encode(body);
+    compile_match_arms(&m.cases, subject_vt, scratch_local, body, ctx, state)
+}
+fn compile_match_arms(
+    cases: &[ast::Case],
+    subject_vt: ValType,
+    scratch_local: u32,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let (case, rest) = match cases.split_first() {
+        None => return Ok(()),
+        Some(pair) => pair,
+    };
+    let pat = case.patterns.first().ok_or_else(|| "codegen: match case has no pattern".to_string())?;
+    match pat {
+        ast::CasePattern::Wildcard => {
+            // Any cases after a wildcard are unreachable, matching real match semantics.
+            compile_block(&case.body, body, ctx, state)
+        }
+        ast::CasePattern::Name(n) => {
+            let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                && ctx.enum_variants.contains_key(n);
+            if is_variant {
+                compile_variant_eq_arm(n, subject_vt, scratch_local, case, rest, body, ctx, state)
+            } else {
+                let idx = ctx
+                    .locals
+                    .get(n)
+                    .copied()
+                    .ok_or_else(|| format!("internal codegen error: missing binding local '{}'", n))?;
+                Instruction::LocalGet(scratch_local).encode(body);
+                Instruction::LocalSet(idx).encode(body);
+                ctx.type_env.borrow_mut().insert(n.clone(), TypeScheme::mono(plum_type_from_valtype_hint(subject_vt)));
+                compile_block(&case.body, body, ctx, state)
+                // A binding arm always matches — any following cases are unreachable.
+            }
+        }
+        ast::CasePattern::Int(n) => {
+            if subject_vt != ValType::I64 {
+                return Err("codegen: integer match pattern against a non-Int subject".to_string());
+            }
+            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::I64Const(*n).encode(body);
+            Instruction::I64Eq.encode(body);
+            Instruction::If(BlockType::Empty).encode(body);
+            compile_block(&case.body, body, ctx, state)?;
+            Instruction::Else.encode(body);
+            compile_match_arms(rest, subject_vt, scratch_local, body, ctx, state)?;
+            Instruction::End.encode(body);
+            Ok(())
+        }
+        ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
+        ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
+        ast::CasePattern::Class { .. } => Err("codegen: constructor match patterns are not yet supported".to_string()),
+    }
+}
+#[allow(clippy::too_many_arguments)]
+fn compile_variant_eq_arm(
+    name: &str,
+    subject_vt: ValType,
+    scratch_local: u32,
+    case: &ast::Case,
+    rest: &[ast::Case],
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    // Only Bool's own variants have a concrete runtime representation in v1.5.
+    let tag = match name {
+        "True" => 1i32,
+        "False" => 0i32,
+        other => return Err(format!("codegen: enum variant pattern '{}' is not yet supported (only True/False)", other)),
+    };
+    if subject_vt != ValType::I32 {
+        return Err("codegen: Bool match pattern against a non-Bool subject".to_string());
+    }
+    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::I32Const(tag).encode(body);
+    Instruction::I32Eq.encode(body);
+    Instruction::If(BlockType::Empty).encode(body);
+    compile_block(&case.body, body, ctx, state)?;
+    Instruction::Else.encode(body);
+    compile_match_arms(rest, subject_vt, scratch_local, body, ctx, state)?;
+    Instruction::End.encode(body);
+    Ok(())
+}
+fn plum_type_from_valtype_hint(vt: ValType) -> PlumType {
+    match vt {
+        ValType::I64 => PlumType::TInt,
+        ValType::F64 => PlumType::TFloat,
+        _ => PlumType::TVar("_".to_string()),
+    }
+}
-fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<(), String> {
+fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
     match expr {
         ast::Expr::Int(n) => {
             Instruction::I64Const(*n).encode(body);
@@ -557,42 +913,40 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::F64Const(*f).encode(body);
         }
         ast::Expr::Var(name) => {
-            if name == "true" {
-                Instruction::I32Const(1).encode(body);
-            } else if name == "false" {
-                Instruction::I32Const(0).encode(body);
-            } else {
-                let idx = *ctx
+            let idx = *ctx
-                    .locals
+                .locals
-                    .get(name.as_str())
+                .get(name.as_str())
-                    .ok_or_else(|| format!("undeclared variable '{}'", name))?;
+                .ok_or_else(|| format!("undeclared variable '{}'", name))?;
-                Instruction::LocalGet(idx).encode(body);
+            Instruction::LocalGet(idx).encode(body);
-            }
         }
         ast::Expr::Paren(inner) => {
-            compile_expr(inner, body, ctx)?;
+            compile_expr(inner, body, ctx, state)?;
         }
-        ast::Expr::Unary(u) => {
+        ast::Expr::Unary(u) => match u.op {
-            match u.op {
-                ast::UnOp::Neg => {
+            ast::UnOp::Neg => {
+                if matches!(infer_local_type(&u.operand, ctx), PlumType::TFloat) {
+                    compile_expr(&u.operand, body, ctx, state)?;
+                    Instruction::F64Neg.encode(body);
+                } else {
-                    // WASM has no i64.neg; use i64.const(0) - operand
+                    // WASM has no i64.neg; use 0 - operand.
                     Instruction::I64Const(0).encode(body);
-                    compile_expr(&u.operand, body, ctx)?;
+                    compile_expr(&u.operand, body, ctx, state)?;
                     Instruction::I64Sub.encode(body);
                 }
-                ast::UnOp::Pos => {
-                    compile_expr(&u.operand, body, ctx)?;
-                }
             }
+            ast::UnOp::Pos => {
+                compile_expr(&u.operand, body, ctx, state)?;
-        }
+            }
+        },
         ast::Expr::Binary(b) => {
+            let is_float = matches!(infer_local_type(&b.left, ctx), PlumType::TFloat);
-            compile_expr(&b.left, body, ctx)?;
+            compile_expr(&b.left, body, ctx, state)?;
-            compile_expr(&b.right, body, ctx)?;
+            compile_expr(&b.right, body, ctx, state)?;
             match b.op {
-                ast::BinOp::Add => Instruction::I64Add.encode(body),
+                ast::BinOp::Add => if is_float { Instruction::F64Add } else { Instruction::I64Add }.encode(body),
-                ast::BinOp::Sub => Instruction::I64Sub.encode(body),
+                ast::BinOp::Sub => if is_float { Instruction::F64Sub } else { Instruction::I64Sub }.encode(body),
-                ast::BinOp::Mul => Instruction::I64Mul.encode(body),
+                ast::BinOp::Mul => if is_float { Instruction::F64Mul } else { Instruction::I64Mul }.encode(body),
-                ast::BinOp::Div => Instruction::I64DivS.encode(body),
+                ast::BinOp::Div => if is_float { Instruction::F64Div } else { Instruction::I64DivS }.encode(body),
                 ast::BinOp::Mod => Instruction::I64RemS.encode(body),
                 ast::BinOp::BitOr => Instruction::I64Or.encode(body),
                 ast::BinOp::BitAnd => Instruction::I64And.encode(body),
@@ -600,40 +954,55 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                 ast::BinOp::Shl => Instruction::I64Shl.encode(body),
                 ast::BinOp::Shr => Instruction::I64ShrS.encode(body),
                 ast::BinOp::Range => {
-                    // Range used outside of For: leave end on stack (start consumed)
+                    // Range used outside of `for`: leave end on stack (start consumed).
                 }
             }
         }
         ast::Expr::Bool(b) => {
-            compile_expr(&b.left, body, ctx)?;
+            compile_expr(&b.left, body, ctx, state)?;
-            compile_expr(&b.right, body, ctx)?;
+            compile_expr(&b.right, body, ctx, state)?;
             match b.op {
                 ast::BoolOp::And => Instruction::I32And.encode(body),
                 ast::BoolOp::Or => Instruction::I32Or.encode(body),
             }
         }
         ast::Expr::Not(inner) => {
-            compile_expr(inner, body, ctx)?;
+            compile_expr(inner, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
         }
         ast::Expr::Compare(c) => {
+            let is_float = matches!(infer_local_type(&c.left, ctx), PlumType::TFloat);
-            compile_expr(&c.left, body, ctx)?;
+            compile_expr(&c.left, body, ctx, state)?;
-            compile_expr(&c.right, body, ctx)?;
+            compile_expr(&c.right, body, ctx, state)?;
+            if is_float {
-            match c.op {
+                match c.op {
+                    ast::CmpOp::Lt => Instruction::F64Lt,
+                    ast::CmpOp::Lte => Instruction::F64Le,
+                    ast::CmpOp::Eq => Instruction::F64Eq,
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::F64Ne,
+                    ast::CmpOp::Gte => Instruction::F64Ge,
+                    ast::CmpOp::Gt => Instruction::F64Gt,
+                }
+                .encode(body);
+            } else {
+                match c.op {
-                ast::CmpOp::Lt => Instruction::I64LtS.encode(body),
+                    ast::CmpOp::Lt => Instruction::I64LtS,
-                ast::CmpOp::Lte => Instruction::I64LeS.encode(body),
+                    ast::CmpOp::Lte => Instruction::I64LeS,
-                ast::CmpOp::Eq => Instruction::I64Eq.encode(body),
+                    ast::CmpOp::Eq => Instruction::I64Eq,
-                ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne.encode(body),
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne,
-                ast::CmpOp::Gte => Instruction::I64GeS.encode(body),
+                    ast::CmpOp::Gte => Instruction::I64GeS,
-                ast::CmpOp::Gt => Instruction::I64GtS.encode(body),
+                    ast::CmpOp::Gt => Instruction::I64GtS,
+                }
+                .encode(body);
             }
         }
         ast::Expr::Ternary(t) => {
+            let result_vt = plum_type_to_valtype(&infer_local_type(&t.then, ctx));
-            compile_expr(&t.condition, body, ctx)?;
+            compile_expr(&t.condition, body, ctx, state)?;
-            Instruction::If(BlockType::Result(ValType::I64)).encode(body);
+            Instruction::If(BlockType::Result(result_vt)).encode(body);
-            compile_expr(&t.then, body, ctx)?;
+            compile_expr(&t.then, body, ctx, state)?;
             Instruction::Else.encode(body);
-            compile_expr(&t.else_, body, ctx)?;
+            compile_expr(&t.else_, body, ctx, state)?;
             Instruction::End.encode(body);
         }
         ast::Expr::FnCall(call) => {
@@ -643,7 +1012,7 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
                     ast::Arg::Keyword { value, .. } => value,
                     ast::Arg::Pair { value, .. } => value,
                 };
-                compile_expr(arg_expr, body, ctx)?;
+                compile_expr(arg_expr, body, ctx, state)?;
             }
             let func_idx = ctx
                 .func_ids
@@ -652,13 +1021,125 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx) -> Result<
             Instruction::Call(*func_idx).encode(body);
         }
         ast::Expr::Self_ => {
+            let idx = ctx
+                .locals
+                .get("self")
+                .copied()
-            return Err("'self' not supported in v1 codegen".to_string());
+                .ok_or_else(|| "codegen: 'self' used outside a method".to_string())?;
+            Instruction::LocalGet(idx).encode(body);
         }
-        ast::Expr::TypeName(_) | ast::Expr::ClassCall(_) | ast::Expr::Attribute(_) => {
+        ast::Expr::TypeName(n) => match n.as_str() {
+            "True" => Instruction::I32Const(1).encode(body),
+            "False" => Instruction::I32Const(0).encode(body),
+            other => return Err(format!("codegen: type name '{}' is not yet supported as a value", other)),
+        },
+        ast::Expr::ClassCall(call) => {
+            let fields = ctx
+                .classes
+                .get(&call.type_name)
+                .ok_or_else(|| format!("codegen: unknown class '{}'", call.type_name))?
+                .clone();
+            let size = (fields.len() as i32) * 8;
+            let scratch_key = expr as *const ast::Expr as usize;
+            let scratch_idx = *ctx
+                .classcall_scratch
+                .get(&scratch_key)
+                .ok_or_else(|| "internal codegen error: missing classcall scratch slot".to_string())?;
+            let scratch_local = ctx.classcall_scratch_base + scratch_idx;
+            // base = bump_global; bump_global += size (runtime bump allocation, so every
+            // call — even inside a loop — gets a fresh, non-overlapping region).
+            Instruction::GlobalGet(ctx.bump_global).encode(body);
+            Instruction::LocalSet(scratch_local).encode(body);
+            Instruction::GlobalGet(ctx.bump_global).encode(body);
-            Instruction::I64Const(0).encode(body);
+            Instruction::I32Const(size).encode(body);
+            Instruction::I32Add.encode(body);
+            Instruction::GlobalSet(ctx.bump_global).encode(body);
+            for fa in &call.fields {
+                let (field_idx, field_ty) = fields
+                    .iter()
+                    .position(|(n, _)| n == &fa.name)
+                    .map(|i| (i, fields[i].1.clone()))
+                    .ok_or_else(|| format!("codegen: unknown field '{}' on class '{}'", fa.name, call.type_name))?;
+                Instruction::LocalGet(scratch_local).encode(body);
+                compile_expr(&fa.value, body, ctx, state)?;
+                let offset = (field_idx as u64) * 8;
+                match plum_type_to_valtype(&field_ty) {
+                    ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                    ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                    _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                };
+            }
+            Instruction::LocalGet(scratch_local).encode(body);
         }
+        ast::Expr::Attribute(attr) => {
+            let obj_ty = infer_local_type(&attr.object, ctx);
+            match &attr.attr {
+                ast::AttrKind::Field(field_name) => {
+                    let class_name = match &obj_ty {
+                        PlumType::TNamed(n) => n.clone(),
+                        other => return Err(format!("codegen: cannot access field '{}' on non-class type {}", field_name, other)),
+                    };
+                    let fields = ctx
+                        .classes
+                        .get(&class_name)
+                        .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
+                    let (field_idx, field_ty) = fields
+                        .iter()
+                        .position(|(n, _)| n == field_name)
+                        .map(|i| (i, fields[i].1.clone()))
+                        .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                    compile_expr(&attr.object, body, ctx, state)?;
+                    let offset = (field_idx as u64) * 8;
+                    match plum_type_to_valtype(&field_ty) {
+                        ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                        ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                        _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                    };
+                }
+                ast::AttrKind::Method(call) => {
+                    let class_name = match &obj_ty {
+                        PlumType::TNamed(n) => n.clone(),
+                        other => return Err(format!("codegen: cannot call method '{}' on non-class type {}", call.name, other)),
+                    };
+                    let key = format!("{}::{}", class_name, call.name);
+                    let func_idx = *ctx
+                        .func_ids
+                        .get(&key)
+                        .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, call.name))?;
+                    compile_expr(&attr.object, body, ctx, state)?; // push self
+                    for arg in &call.args {
+                        let arg_expr = match arg {
+                            ast::Arg::Positional(e) => e,
+                            ast::Arg::Keyword { value, .. } => value,
+                            ast::Arg::Pair { value, .. } => value,
+                        };
+                        compile_expr(arg_expr, body, ctx, state)?;
+                    }
+                    Instruction::Call(func_idx).encode(body);
+                }
+            }
+        }
-        ast::Expr::String(_) => {
+        ast::Expr::String(s) => {
+            let mut text = String::new();
+            for part in &s.parts {
+                match part {
+                    ast::StringPart::Text(t) => text.push_str(t),
+                    ast::StringPart::Interp(_) => {
+                        return Err("codegen: string interpolation is not yet supported".to_string());
+                    }
+                }
+            }
+            let bytes = text.as_bytes();
+            let offset = state.next_string_offset;
+            let mut data = Vec::with_capacity(4 + bytes.len());
+            data.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
+            data.extend_from_slice(bytes);
+            state.next_string_offset += data.len() as u32;
+            state.data_segments.push((offset, data));
-            Instruction::I32Const(0).encode(body);
+            Instruction::I32Const(offset as i32).encode(body);
         }
     }
     Ok(())

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -31,8 +31,12 @@ fn output_validates() {
 #[test]
 fn factorial_compiles() {
-    // Simple recursive function that the v1 codegen can handle
+    let src = "\
-    let src = "factorial(x: Int) -> Int =\n  x\n";
+factorial(x: Int) -> Int =
+  if x < 2
+    return 1
+  return x * factorial(x - 1)
+";
     let source = parse(src);
     let bytes = compile_source(&source).expect("factorial should compile");
     assert_eq!(&bytes[0..4], b"\0asm");
@@ -49,3 +53,255 @@ fn give42_compiles_and_exports() {
     let result = wasmparser::validate(&bytes);
     assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
 }
+fn assert_valid(src: &str) -> Vec<u8> {
+    let source = parse(src);
+    let bytes = compile_source(&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 bool_literals_compile() {
+    assert_valid("main() -> Bool =\n  True\n");
+    assert_valid("main() -> Bool =\n  False\n");
+}
+#[test]
+fn string_literal_compiles() {
+    assert_valid("main() -> Str =\n  \"hello\"\n");
+}
+#[test]
+fn empty_string_literal_compiles() {
+    assert_valid("main() -> Str =\n  \"\"\n");
+}
+#[test]
+fn string_interpolation_is_a_clear_error() {
+    let src = "main() -> Str =\n  x = 1\n  \"{x}\"\n";
+    let source = parse(src);
+    let err = compile_source(&source).expect_err("interpolation should not silently compile");
+    assert!(err.contains("interpolation"), "got: {}", err);
+}
+#[test]
+fn float_arithmetic_and_negation_compile() {
+    assert_valid("main(x: Float) -> Float =\n  y = -x\n  y + 1.5\n");
+}
+#[test]
+fn class_field_and_method_compile() {
+    let src = "\
+type Cat =
+  name: Str
+  age: Int
+getAge<Cat>() -> Int =
+  self.age
+makeCat() -> Int =
+  c = Cat(name: \"x\", age: 3)
+  c.getAge()
+";
+    assert_valid(src);
+}
+#[test]
+fn nested_class_call_compiles() {
+    let src = "\
+type Pair =
+  a: Int
+  b: Int
+type Wrapper =
+  inner: Pair
+  tag: Int
+make() -> Int =
+  w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)
+  w.tag
+";
+    assert_valid(src);
+}
+#[test]
+fn match_with_int_and_wildcard_compiles() {
+    let src = "main(a: Int) -> Int =\n  match a\n    1 =>\n      return 10\n    _ =>\n      return 0\n";
+    assert_valid(src);
+}
+#[test]
+fn match_binding_pattern_compiles() {
+    let src = "main(a: Int) -> Int =\n  match a\n    x =>\n      return x\n";
+    assert_valid(src);
+}
+#[test]
+fn match_bool_variant_pattern_compiles() {
+    let src = "main(a: Bool) -> Int =\n  match a\n    True =>\n      return 1\n    False =>\n      return 0\n";
+    assert_valid(src);
+}
+#[test]
+fn match_string_pattern_is_a_clear_error() {
+    let src = "main(a: Str) -> Int =\n  match a\n    \"x\" =>\n      1\n    _ =>\n      0\n";
+    let source = parse(src);
+    let err = compile_source(&source).expect_err("string match patterns are not yet supported");
+    assert!(err.contains("string match"), "got: {}", err);
+}
+/// 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 run_main(bytes: &[u8]) -> i64 {
+    let engine = wasmtime::Engine::default();
+    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")
+}
+#[test]
+fn factorial_runs_correctly() {
+    let src = "\
+factorial(x: Int) -> Int =
+  if x < 2
+    return 1
+  return x * factorial(x - 1)
+main() -> Int =
+  factorial(5)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 120);
+}
+#[test]
+fn class_field_and_method_run_correctly() {
+    let src = "\
+type Cat =
+  name: Str
+  age: Int
+getAge<Cat>() -> Int =
+  self.age
+main() -> Int =
+  c = Cat(name: \"x\", age: 7)
+  c.getAge()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn nested_class_call_runs_correctly() {
+    let src = "\
+type Pair =
+  a: Int
+  b: Int
+type Wrapper =
+  inner: Pair
+  tag: Int
+main() -> Int =
+  w = Wrapper(inner: Pair(a: 11, b: 22), tag: 99)
+  w.inner.b
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 22);
+}
+#[test]
+fn repeated_class_call_in_a_loop_does_not_alias() {
+    // 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
+sumBoxes() -> Int =
+  total = 0
+  for i in 0..5
+    b = Box(v: i)
+    total = total + b.v
+  return total
+main() -> Int =
+  sumBoxes()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 10);
+}
+#[test]
+fn match_int_and_wildcard_run_correctly() {
+    let src = "\
+classify(a: Int) -> Int =
+  match a
+    1 =>
+      return 100
+    2 =>
+      return 200
+    _ =>
+      return 0
+main() -> Int =
+  classify(2)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 200);
+}
+#[test]
+fn match_bool_variant_pattern_runs_correctly() {
+    // 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 = "\
+pick(a: Bool) -> Int =
+  match a
+    True =>
+      return 1
+    False =>
+      return 0
+main() -> Int =
+  pick(False)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 0);
+}
+#[test]
+fn lowercase_single_word_function_call_runs_correctly() {
+    // 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 = "\
+double(n: Int) -> Int =
+  n * 2
+main() -> Int =
+  double(21)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}