msys2: get python via numpy dependencies

flake: update nixpkgs
cargo: update dependencies
2024-09-30 14:27:30 +08:00 · 2024-09-30 14:22:40 +08:00 · 2024-09-30 14:14:43 +08:00 · 2024-09-13 12:12:13 +08:00 · 2024-09-13 11:11:14 +08:00 · 2024-09-13 11:11:14 +08:00
90 changed files with 10435 additions and 4393 deletions
--- a/.clang-format
+++ b/.clang-format
@ -0,0 +1,32 @@
 BasedOnStyle: LLVM
 Language: Cpp
 Standard: Cpp11
 AccessModifierOffset: -1
 AlignEscapedNewlines: Left
 AlwaysBreakAfterReturnType: None
 AlwaysBreakTemplateDeclarations: Yes
 AllowAllParametersOfDeclarationOnNextLine: false
 AllowShortFunctionsOnASingleLine: Inline
 BinPackParameters: false
 BreakBeforeBinaryOperators: NonAssignment
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: AfterColon
 BreakInheritanceList: AfterColon
 ColumnLimit: 120
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ContinuationIndentWidth: 4
 DerivePointerAlignment: false
 IndentCaseLabels: true
 IndentPPDirectives: None
 IndentWidth: 4
 MaxEmptyLinesToKeep: 1
 PointerAlignment: Left
 ReflowComments: true
 SortIncludes: false
 SortUsingDeclarations: true
 SpaceAfterTemplateKeyword: false
 SpacesBeforeTrailingComments: 2
 TabWidth: 4
 UseTab: Never
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,4 @@
 __pycache__
 /target
 /nac3standalone/demo/linalg/target
 nix/windows/msys2
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -8,17 +8,17 @@ repos:
    hooks:
      - id: nac3-cargo-fmt
        name: nac3 cargo format
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo fmt on the codebase.
-        args: [fmt]
+        args: [develop, -c, cargo, fmt, --all]
      - id: nac3-cargo-clippy
        name: nac3 cargo clippy
-        entry: cargo
+        entry: nix
        language: system
        types: [file, rust]
        pass_filenames: false
        description: Runs cargo clippy on the codebase.
-        args: [clippy, --tests]
+        args: [develop, -c, cargo, clippy, --tests]
--- a/Cargo.lock
+++ b/Cargo.lock
@ -26,9 +26,9 @@ dependencies = [
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
 dependencies = [
 "anstyle",
 "anstyle-parse",
@ -41,36 +41,36 @@ dependencies = [
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
 dependencies = [
 "utf8parse",
 ]
 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
 "anstyle",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
@ -84,30 +84,39 @@ dependencies = [
 [[package]]
 name = "autocfg"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 [[package]]
 name = "bit-set"
-version = "0.5.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+checksum = "f0481a0e032742109b1133a095184ee93d88f3dc9e0d28a5d033dc77a073f44f"
 dependencies = [
 "bit-vec",
 ]
 [[package]]
 name = "bit-vec"
-version = "0.6.3"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+checksum = "d2c54ff287cfc0a34f38a6b832ea1bd8e448a330b3e40a50859e6488bee07f22"
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 [[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 = "byteorder"
@ -117,9 +126,12 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "cc"
-version = "1.0.99"
+version = "1.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+checksum = "9540e661f81799159abee814118cc139a2004b3a3aa3ea37724a1b66530b90e0"
 dependencies = [
 "shlex",
 ]
 [[package]]
 name = "cfg-if"
@ -129,9 +141,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "clap"
-version = "4.5.7"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f"
+checksum = "b0956a43b323ac1afaffc053ed5c4b7c1f1800bacd1683c353aabbb752515dd3"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -139,9 +151,9 @@ dependencies = [
 [[package]]
 name = "clap_builder"
-version = "4.5.7"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f"
+checksum = "4d72166dd41634086d5803a47eb71ae740e61d84709c36f3c34110173db3961b"
 dependencies = [
 "anstream",
 "anstyle",
@ -151,27 +163,27 @@ dependencies = [
 [[package]]
 name = "clap_derive"
-version = "4.5.5"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
 name = "clap_lex"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 [[package]]
 name = "console"
@ -182,7 +194,16 @@ dependencies = [
 "encode_unicode",
 "lazy_static",
 "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
 name = "cpufeatures"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0"
 dependencies = [
 "libc",
 ]
 [[package]]
@ -242,10 +263,24 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
 [[package]]
-name = "crunchy"
+name = "crypto-common"
-version = "0.2.2"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
 "generic-array",
 "typenum",
 ]
 [[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 = "dirs-next"
@ -270,9 +305,9 @@ dependencies = [
 [[package]]
 name = "either"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 [[package]]
 name = "ena"
@ -302,14 +337,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
 "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
 name = "fastrand"
-version = "2.1.0"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+checksum = "e8c02a5121d4ea3eb16a80748c74f5549a5665e4c21333c6098f283870fbdea6"
 [[package]]
 name = "fixedbitset"
@ -326,6 +361,16 @@ dependencies = [
 "byteorder",
 ]
 [[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 = "getopts"
 version = "0.2.21"
@ -385,9 +430,9 @@ dependencies = [
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
 dependencies = [
 "equivalent",
 "hashbrown 0.14.5",
@ -401,9 +446,9 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 [[package]]
 name = "inkwell"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b597a7b2cdf279aeef6d7149071e35e4bc87c2cf05a5b7f2d731300bffe587ea"
+checksum = "40fb405537710d51f6bdbc8471365ddd4cd6d3a3c3ad6e0c8291691031ba94b2"
 dependencies = [
 "either",
 "inkwell_internals",
@ -415,13 +460,13 @@ dependencies = [
 [[package]]
 name = "inkwell_internals"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa4d8d74483041a882adaa9a29f633253a66dde85055f0495c121620ac484b2"
+checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
@ -440,18 +485,9 @@ dependencies = [
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 [[package]]
 name = "itertools"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
 dependencies = [
 "either",
 ]
 [[package]]
 name = "itertools"
@ -469,53 +505,62 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 [[package]]
-name = "lalrpop"
+name = "keccak"
-version = "0.20.2"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cb077ad656299f160924eb2912aa147d7339ea7d69e1b5517326fdcec3c1ca"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
 dependencies = [
 "cpufeatures",
 ]
 [[package]]
 name = "lalrpop"
 version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e56f323e2d610628d1f5bdd39168a774674ac7989ed67011963bb3f71edd797"
 dependencies = [
 "ascii-canvas",
 "bit-set",
 "ena",
- "itertools 0.11.0",
+ "itertools",
 "lalrpop-util",
 "petgraph",
 "pico-args",
 "regex",
 "regex-syntax",
 "sha3",
 "string_cache",
 "term",
 "tiny-keccak",
 "unicode-xid",
 "walkdir",
 ]
 [[package]]
 name = "lalrpop-util"
-version = "0.20.2"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+checksum = "108dc8f5dabad92c65a03523055577d847f5dcc00f3e7d3a68bc4d48e01d8fe1"
 dependencies = [
 "regex-automata",
 ]
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 [[package]]
 name = "libloading"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
 "cfg-if",
 "windows-targets",
@ -568,9 +613,9 @@ dependencies = [
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 [[package]]
 name = "memchr"
@ -591,11 +636,9 @@ dependencies = [
 name = "nac3artiq"
 version = "0.1.0"
 dependencies = [
- "inkwell",
+ "itertools",
 "itertools 0.13.0",
 "nac3core",
 "nac3ld",
 "nac3parser",
 "parking_lot",
 "pyo3",
 "tempfile",
@ -616,11 +659,11 @@ name = "nac3core"
 version = "0.1.0"
 dependencies = [
 "crossbeam",
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
 "indoc",
 "inkwell",
 "insta",
- "itertools 0.13.0",
+ "itertools",
 "nac3parser",
 "parking_lot",
 "rayon",
@ -658,9 +701,7 @@ name = "nac3standalone"
 version = "0.1.0"
 dependencies = [
 "clap",
 "inkwell",
 "nac3core",
 "nac3parser",
 "parking_lot",
 ]
@ -672,9 +713,12 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
 dependencies = [
 "portable-atomic",
 ]
 [[package]]
 name = "parking_lot"
@ -706,7 +750,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
 "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.5.0",
 ]
 [[package]]
@ -749,7 +793,7 @@ dependencies = [
 "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
@ -778,15 +822,18 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 [[package]]
 name = "portable-atomic"
-version = "1.6.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
 dependencies = [
 "zerocopy",
 ]
 [[package]]
 name = "precomputed-hash"
@ -796,9 +843,9 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 [[package]]
 name = "proc-macro2"
-version = "1.0.85"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
 "unicode-ident",
 ]
@ -850,7 +897,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
@ -863,14 +910,14 @@ dependencies = [
 "proc-macro2",
 "pyo3-build-config",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
 name = "quote"
-version = "1.0.36"
+version = "1.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
 dependencies = [
 "proc-macro2",
 ]
@ -927,18 +974,18 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "355ae415ccd3a04315d3f8246e86d67689ea74d88d915576e1589a351062a13b"
 dependencies = [
 "bitflags",
 ]
 [[package]]
 name = "redox_users"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 dependencies = [
 "getrandom",
 "libredox",
@ -947,9 +994,9 @@ dependencies = [
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -959,9 +1006,9 @@ dependencies = [
 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -970,9 +1017,9 @@ dependencies = [
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 [[package]]
 name = "runkernel"
@ -983,15 +1030,15 @@ dependencies = [
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811"
 dependencies = [
 "bitflags",
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
@ -1029,31 +1076,32 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
 "itoa",
 "memchr",
 "ryu",
 "serde",
 ]
@ -1071,10 +1119,26 @@ dependencies = [
 ]
 [[package]]
-name = "similar"
+name = "sha3"
-version = "2.5.0"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
 dependencies = [
 "digest",
 "keccak",
 ]
 [[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 [[package]]
 name = "similar"
 version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
 [[package]]
 name = "siphasher"
@ -1120,9 +1184,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 [[package]]
 name = "strum"
-version = "0.26.2"
+version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d8cec3501a5194c432b2b7976db6b7d10ec95c253208b45f83f7136aa985e29"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
 [[package]]
 name = "strum_macros"
@ -1134,7 +1198,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
@ -1150,9 +1214,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "2.0.66"
+version = "2.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5"
+checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1161,20 +1225,21 @@ dependencies = [
 [[package]]
 name = "target-lexicon"
-version = "0.12.14"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b"
 dependencies = [
 "cfg-if",
 "fastrand",
 "once_cell",
 "rustix",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 [[package]]
@ -1203,32 +1268,29 @@ dependencies = [
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84"
 dependencies = [
 "thiserror-impl",
 ]
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
 [[package]]
-name = "tiny-keccak"
+name = "typenum"
-version = "2.0.2"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 dependencies = [
 "crunchy",
 ]
 [[package]]
 name = "unic-char-property"
@ -1284,27 +1346,27 @@ dependencies = [
 [[package]]
 name = "unicode-ident"
-version = "1.0.12"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"
 [[package]]
 name = "unicode-width"
-version = "0.1.13"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 [[package]]
 name = "unicode-xid"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 [[package]]
 name = "unicode_names2"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "addeebf294df7922a1164f729fb27ebbbcea99cc32b3bf08afab62757f707677"
+checksum = "d1673eca9782c84de5f81b82e4109dcfb3611c8ba0d52930ec4a9478f547b2dd"
 dependencies = [
 "phf",
 "unicode_names2_generator",
@ -1312,9 +1374,9 @@ dependencies = [
 [[package]]
 name = "unicode_names2_generator"
-version = "1.2.2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f444b8bba042fe3c1251ffaca35c603f2dc2ccc08d595c65a8c4f76f3e8426c0"
+checksum = "b91e5b84611016120197efd7dc93ef76774f4e084cd73c9fb3ea4a86c570c56e"
 dependencies = [
 "getopts",
 "log",
@ -1336,9 +1398,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 [[package]]
 name = "walkdir"
@ -1374,11 +1436,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 [[package]]
@ -1397,10 +1459,19 @@ dependencies = [
 ]
 [[package]]
-name = "windows-targets"
+name = "windows-sys"
-version = "0.52.5"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
 "windows-targets",
 ]
 [[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",
@ -1414,51 +1485,51 @@ dependencies = [
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "yaml-rust"
@ -1471,20 +1542,21 @@ dependencies = [
 [[package]]
 name = "zerocopy"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
 "byteorder",
 "zerocopy-derive",
 ]
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.66",
+ "syn 2.0.79",
 ]
--- a/flake.lock
+++ b/flake.lock
@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1718530797,
+        "lastModified": 1727348695,
-        "narHash": "sha256-pup6cYwtgvzDpvpSCFh1TEUjw2zkNpk8iolbKnyFmmU=",
+        "narHash": "sha256-J+PeFKSDV+pHL7ukkfpVzCOO7mBSrrpJ3svwBFABbhI=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "b60ebf54c15553b393d144357375ea956f89e9a9",
+        "rev": "1925c603f17fc89f4c8f6bf6f631a802ad85d784",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@ -6,6 +6,7 @@
  outputs = { self, nixpkgs }:
    let
      pkgs = import nixpkgs { system = "x86_64-linux"; };
      pkgs32 = import nixpkgs { system = "i686-linux"; };
    in rec {
      packages.x86_64-linux = rec {
        llvm-nac3 = pkgs.callPackage ./nix/llvm {};
@ -15,6 +16,22 @@
          ln -s ${pkgs.llvmPackages_14.clang-unwrapped}/bin/clang $out/bin/clang-irrt
          ln -s ${pkgs.llvmPackages_14.llvm.out}/bin/llvm-as $out/bin/llvm-as-irrt
          '';
        demo-linalg-stub = pkgs.rustPlatform.buildRustPackage {
          name = "demo-linalg-stub";
          src = ./nac3standalone/demo/linalg;
          cargoLock = {
            lockFile = ./nac3standalone/demo/linalg/Cargo.lock;
          };
          doCheck = false;
        };
        demo-linalg-stub32 = pkgs32.rustPlatform.buildRustPackage {
          name = "demo-linalg-stub32";
          src = ./nac3standalone/demo/linalg;
          cargoLock = {
            lockFile = ./nac3standalone/demo/linalg/Cargo.lock;
          };
          doCheck = false;
        };
        nac3artiq = pkgs.python3Packages.toPythonModule (
          pkgs.rustPlatform.buildRustPackage rec {
            name = "nac3artiq";
@ -24,7 +41,7 @@
              lockFile = ./Cargo.lock;
            };
            passthru.cargoLock = cargoLock;
-            nativeBuildInputs = [ pkgs.python3 pkgs.llvmPackages_14.clang llvm-tools-irrt pkgs.llvmPackages_14.llvm.out llvm-nac3 ];
+            nativeBuildInputs = [ pkgs.python3 (pkgs.wrapClangMulti pkgs.llvmPackages_14.clang) llvm-tools-irrt pkgs.llvmPackages_14.llvm.out llvm-nac3 ];
            buildInputs = [ pkgs.python3 llvm-nac3 ];
            checkInputs = [ (pkgs.python3.withPackages(ps: [ ps.numpy ps.scipy ])) ];
            checkPhase =
@ -32,7 +49,9 @@
              echo "Checking nac3standalone demos..."
              pushd nac3standalone/demo
              patchShebangs .
-              ./check_demos.sh
+              export DEMO_LINALG_STUB=${demo-linalg-stub}/lib/liblinalg.a
              export DEMO_LINALG_STUB32=${demo-linalg-stub32}/lib/liblinalg.a
              ./check_demos.sh -i686
              popd
              echo "Running Cargo tests..."
              cargoCheckHook
@ -149,7 +168,7 @@
        buildInputs = with pkgs; [
          # build dependencies
          packages.x86_64-linux.llvm-nac3
-          llvmPackages_14.clang llvmPackages_14.llvm.out  # for running nac3standalone demos
+          (pkgs.wrapClangMulti llvmPackages_14.clang) llvmPackages_14.llvm.out  # for running nac3standalone demos
          packages.x86_64-linux.llvm-tools-irrt
          cargo
          rustc
@ -162,6 +181,11 @@
          pre-commit
          rustfmt
        ];
        shellHook =
          ''
          export DEMO_LINALG_STUB=${packages.x86_64-linux.demo-linalg-stub}/lib/liblinalg.a
          export DEMO_LINALG_STUB32=${packages.x86_64-linux.demo-linalg-stub32}/lib/liblinalg.a
          '';
      };
      devShells.x86_64-linux.msys2 = pkgs.mkShell {
        name = "nac3-dev-shell-msys2";
--- a/nac3artiq/Cargo.toml
+++ b/nac3artiq/Cargo.toml
@ -13,14 +13,9 @@ itertools = "0.13"
 pyo3 = { version = "0.21", features = ["extension-module", "gil-refs"] }
 parking_lot = "0.12"
 tempfile = "3.10"
 nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }
 nac3ld = { path = "../nac3ld" }
 [dependencies.inkwell]
 version = "0.4"
 default-features = false
 features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
 [features]
 init-llvm-profile = []
 no-escape-analysis = ["nac3core/no-escape-analysis"]
--- a/nac3artiq/demo/list_cmp.py
+++ b/nac3artiq/demo/list_cmp.py
@ -0,0 +1,24 @@
 from min_artiq import *
 from numpy import int32
@nac3
 class EmptyList:
    core: KernelInvariant[Core]
    def __init__(self):
        self.core = Core()
    @rpc
    def get_empty(self) -> list[int32]:
        return []
    @kernel
    def run(self):
        a: list[int32] = self.get_empty()
        if a != []:
            raise ValueError
 if __name__ == "__main__":
    EmptyList().run()
--- a/nac3artiq/demo/min_artiq.py
+++ b/nac3artiq/demo/min_artiq.py
@ -112,10 +112,15 @@ def extern(function):
    register_function(function)
    return function
-def rpc(function):
+
-    """Decorates a function declaration defined by the core device runtime."""
+def rpc(arg=None, flags={}):
-    register_function(function)
+    """Decorates a function or method to be executed on the host interpreter."""
-    return function
+    if arg is None:
        def inner_decorator(function):
            return rpc(function, flags)
        return inner_decorator
    register_function(arg)
    return arg
 def kernel(function_or_method):
    """Decorates a function or method to be executed on the core device."""
--- a/nac3artiq/demo/str_abi.py
+++ b/nac3artiq/demo/str_abi.py
@ -0,0 +1,26 @@
 from min_artiq import *
 from numpy import ndarray, zeros as np_zeros
@nac3
 class StrFail:
    core: KernelInvariant[Core]
    def __init__(self):
        self.core = Core()
    @kernel
    def hello(self, arg: str):
        pass
    @kernel
    def consume_ndarray(self, arg: ndarray[str, 1]):
        pass
    def run(self):
        self.hello("world")
        self.consume_ndarray(np_zeros([10], dtype=str))
 if __name__ == "__main__":
    StrFail().run()
--- a/nac3artiq/demo/support_class_attr_issue102.py
+++ b/nac3artiq/demo/support_class_attr_issue102.py
@ -0,0 +1,40 @@
 from min_artiq import *
 from numpy import int32
@nac3
 class Demo:
    attr1: KernelInvariant[int32] = 2
    attr2: int32 = 4
    attr3: Kernel[int32]
    @kernel
    def __init__(self):
        self.attr3 = 8
@nac3
 class NAC3Devices:
    core: KernelInvariant[Core]
    attr4: KernelInvariant[int32] = 16
    def __init__(self):
        self.core = Core()
    @kernel
    def run(self):
        Demo.attr1  # Supported
        # Demo.attr2  # Field not accessible on Kernel
        # Demo.attr3  # Only attributes can be accessed in this way
        # Demo.attr1 = 2  # Attributes are immutable
        self.attr4  # Attributes can be accessed within class
        obj = Demo()
        obj.attr1  # Attributes can be accessed by class objects
        NAC3Devices.attr4  # Attributes accessible for classes without __init__
 if __name__ == "__main__":
    NAC3Devices().run()
--- a/nac3artiq/src/codegen.rs
+++ b/nac3artiq/src/codegen.rs
--- a/nac3artiq/src/lib.rs
+++ b/nac3artiq/src/lib.rs
@ -23,7 +23,10 @@ use std::process::Command;
 use std::rc::Rc;
 use std::sync::Arc;
-use inkwell::{
+use itertools::Itertools;
 use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
 use nac3core::inkwell::{
    context::Context,
    memory_buffer::MemoryBuffer,
    module::{Linkage, Module},
    passes::PassBuilderOptions,
@ -31,12 +34,10 @@ use inkwell::{
    targets::*,
    OptimizationLevel,
 };
 use itertools::Itertools;
 use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
 use nac3core::toplevel::builtins::get_exn_constructor;
-use nac3core::typecheck::typedef::{TypeEnum, Unifier, VarMap};
+use nac3core::typecheck::typedef::{into_var_map, TypeEnum, Unifier, VarMap};
-use nac3parser::{
+use nac3core::nac3parser::{
-    ast::{ExprKind, Stmt, StmtKind, StrRef},
+    ast::{Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
    parser::parse_program,
 };
 use pyo3::create_exception;
@ -50,7 +51,7 @@ use nac3core::{
    codegen::{concrete_type::ConcreteTypeStore, CodeGenTask, WithCall, WorkerRegistry},
    symbol_resolver::SymbolResolver,
    toplevel::{
-        composer::{ComposerConfig, TopLevelComposer},
+        composer::{BuiltinFuncCreator, BuiltinFuncSpec, ComposerConfig, TopLevelComposer},
        DefinitionId, GenCall, TopLevelDef,
    },
    typecheck::typedef::{FunSignature, FuncArg},
@ -59,13 +60,13 @@ use nac3core::{
 use nac3ld::Linker;
 use tempfile::{self, TempDir};
 use crate::codegen::attributes_writeback;
 use crate::{
-    codegen::{rpc_codegen_callback, ArtiqCodeGenerator},
+    codegen::{
        attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback, ArtiqCodeGenerator,
    },
    symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver},
 };
 use tempfile::{self, TempDir};
 mod codegen;
 mod symbol_resolver;
@ -126,7 +127,7 @@ struct Nac3 {
    isa: Isa,
    time_fns: &'static (dyn TimeFns + Sync),
    primitive: PrimitiveStore,
-    builtins: Vec<(StrRef, FunSignature, Arc<GenCall>)>,
+    builtins: Vec<BuiltinFuncSpec>,
    pyid_to_def: Arc<RwLock<HashMap<u64, DefinitionId>>>,
    primitive_ids: PrimitivePythonId,
    working_directory: TempDir,
@ -193,10 +194,8 @@ impl Nac3 {
                    body.retain(|stmt| {
                        if let StmtKind::FunctionDef { ref decorator_list, .. } = stmt.node {
                            decorator_list.iter().any(|decorator| {
-                                if let ExprKind::Name { id, .. } = decorator.node {
+                                if let Some(id) = decorator_id_string(decorator) {
-                                    id.to_string() == "kernel"
+                                    id == "kernel" || id == "portable" || id == "rpc"
                                        || id.to_string() == "portable"
                                        || id.to_string() == "rpc"
                                } else {
                                    false
                                }
@ -209,9 +208,8 @@ impl Nac3 {
                }
                StmtKind::FunctionDef { ref decorator_list, .. } => {
                    decorator_list.iter().any(|decorator| {
-                        if let ExprKind::Name { id, .. } = decorator.node {
+                        if let Some(id) = decorator_id_string(decorator) {
-                            let id = id.to_string();
+                            id == "extern" || id == "kernel" || id == "portable" || id == "rpc"
                            id == "extern" || id == "portable" || id == "kernel" || id == "rpc"
                        } else {
                            false
                        }
@ -264,7 +262,7 @@ impl Nac3 {
                    arg_names.len(),
                ));
            }
-            for (i, FuncArg { ty, default_value, name }) in args.iter().enumerate() {
+            for (i, FuncArg { ty, default_value, name, .. }) in args.iter().enumerate() {
                let in_name = match arg_names.get(i) {
                    Some(n) => n,
                    None if default_value.is_none() => {
@ -300,6 +298,64 @@ impl Nac3 {
        None
    }
    /// Returns a [`Vec`] of builtins that needs to be initialized during method compilation time.
    fn get_lateinit_builtins() -> Vec<Box<BuiltinFuncCreator>> {
        vec![
            Box::new(|primitives, unifier| {
                let arg_ty = unifier.get_fresh_var(Some("T".into()), None);
                (
                    "core_log".into(),
                    FunSignature {
                        args: vec![FuncArg {
                            name: "arg".into(),
                            ty: arg_ty.ty,
                            default_value: None,
                            is_vararg: false,
                        }],
                        ret: primitives.none,
                        vars: into_var_map([arg_ty]),
                    },
                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
                        gen_core_log(ctx, &obj, fun, &args, generator)?;
                        Ok(None)
                    }))),
                )
            }),
            Box::new(|primitives, unifier| {
                let arg_ty = unifier.get_fresh_var(Some("T".into()), None);
                (
                    "rtio_log".into(),
                    FunSignature {
                        args: vec![
                            FuncArg {
                                name: "channel".into(),
                                ty: primitives.str,
                                default_value: None,
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "arg".into(),
                                ty: arg_ty.ty,
                                default_value: None,
                                is_vararg: false,
                            },
                        ],
                        ret: primitives.none,
                        vars: into_var_map([arg_ty]),
                    },
                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
                        gen_rtio_log(ctx, &obj, fun, &args, generator)?;
                        Ok(None)
                    }))),
                )
            }),
        ]
    }
    fn compile_method<T>(
        &self,
        obj: &PyAny,
@ -312,6 +368,7 @@ impl Nac3 {
        let size_t = self.isa.get_size_type();
        let (mut composer, mut builtins_def, mut builtins_ty) = TopLevelComposer::new(
            self.builtins.clone(),
            Self::get_lateinit_builtins(),
            ComposerConfig { kernel_ann: Some("Kernel"), kernel_invariant_ann: "KernelInvariant" },
            size_t,
        );
@ -388,7 +445,6 @@ impl Nac3 {
                        pyid_to_type: pyid_to_type.clone(),
                        primitive_ids: self.primitive_ids.clone(),
                        global_value_ids: global_value_ids.clone(),
                        class_names: Mutex::default(),
                        name_to_pyid: name_to_pyid.clone(),
                        module: module.clone(),
                        id_to_pyval: RwLock::default(),
@ -419,9 +475,25 @@ impl Nac3 {
            match &stmt.node {
                StmtKind::FunctionDef { decorator_list, .. } => {
-                    if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
+                    if decorator_list
-                        store_fun.call1(py, (def_id.0.into_py(py), module.getattr(py, name.to_string().as_str()).unwrap())).unwrap();
+                        .iter()
-                        rpc_ids.push((None, def_id));
+                        .any(|decorator| decorator_id_string(decorator) == Some("rpc".to_string()))
                    {
                        store_fun
                            .call1(
                                py,
                                (
                                    def_id.0.into_py(py),
                                    module.getattr(py, name.to_string().as_str()).unwrap(),
                                ),
                            )
                            .unwrap();
                        let is_async = decorator_list.iter().any(|decorator| {
                            decorator_get_flags(decorator)
                                .iter()
                                .any(|constant| *constant == Constant::Str("async".into()))
                        });
                        rpc_ids.push((None, def_id, is_async));
                    }
                }
                StmtKind::ClassDef { name, body, .. } => {
@ -429,19 +501,26 @@ impl Nac3 {
                    let class_obj = module.getattr(py, class_name.as_str()).unwrap();
                    for stmt in body {
                        if let StmtKind::FunctionDef { name, decorator_list, .. } = &stmt.node {
-                            if decorator_list.iter().any(|decorator| matches!(decorator.node, ExprKind::Name { id, .. } if id == "rpc".into())) {
+                            if decorator_list.iter().any(|decorator| {
                                decorator_id_string(decorator) == Some("rpc".to_string())
                            }) {
                                let is_async = decorator_list.iter().any(|decorator| {
                                    decorator_get_flags(decorator)
                                        .iter()
                                        .any(|constant| *constant == Constant::Str("async".into()))
                                });
                                if name == &"__init__".into() {
                                    return Err(CompileError::new_err(format!(
                                        "compilation failed\n----------\nThe constructor of class {} should not be decorated with rpc decorator (at {})",
                                        class_name, stmt.location
                                    )));
                                }
-                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id));
+                                rpc_ids.push((Some((class_obj.clone(), *name)), def_id, is_async));
                            }
                        }
                    }
                }
-                _ => ()
+                _ => (),
            }
            let id = *name_to_pyid.get(&name).unwrap();
@ -480,7 +559,6 @@ impl Nac3 {
            pyid_to_type: pyid_to_type.clone(),
            primitive_ids: self.primitive_ids.clone(),
            global_value_ids: global_value_ids.clone(),
            class_names: Mutex::default(),
            id_to_pyval: RwLock::default(),
            id_to_primitive: RwLock::default(),
            field_to_val: RwLock::default(),
@ -497,6 +575,10 @@ impl Nac3 {
            .register_top_level(synthesized.pop().unwrap(), Some(resolver.clone()), "", false)
            .unwrap();
        // Process IRRT
        let context = Context::create();
        let irrt = load_irrt(&context, resolver.as_ref());
        let fun_signature =
            FunSignature { args: vec![], ret: self.primitive.none, vars: VarMap::new() };
        let mut store = ConcreteTypeStore::new();
@ -534,13 +616,12 @@ impl Nac3 {
        let top_level = Arc::new(composer.make_top_level_context());
        {
            let rpc_codegen = rpc_codegen_callback();
            let defs = top_level.definitions.read();
-            for (class_data, id) in &rpc_ids {
+            for (class_data, id, is_async) in &rpc_ids {
                let mut def = defs[id.0].write();
                match &mut *def {
                    TopLevelDef::Function { codegen_callback, .. } => {
-                        *codegen_callback = Some(rpc_codegen.clone());
+                        *codegen_callback = Some(rpc_codegen_callback(*is_async));
                    }
                    TopLevelDef::Class { methods, .. } => {
                        let (class_def, method_name) = class_data.as_ref().unwrap();
@ -551,7 +632,7 @@ impl Nac3 {
                            if let TopLevelDef::Function { codegen_callback, .. } =
                                &mut *defs[id.0].write()
                            {
-                                *codegen_callback = Some(rpc_codegen.clone());
+                                *codegen_callback = Some(rpc_codegen_callback(*is_async));
                                store_fun
                                    .call1(
                                        py,
@ -625,7 +706,9 @@ impl Nac3 {
            let buffer = buffer.as_slice().into();
            membuffer.lock().push(buffer);
        })));
-        let size_t = if self.isa == Isa::Host { 64 } else { 32 };
+        let size_t = context
            .ptr_sized_int_type(&self.get_llvm_target_machine().get_target_data(), None)
            .get_bit_width();
        let num_threads = if is_multithreaded() { 4 } else { 1 };
        let thread_names: Vec<String> = (0..num_threads).map(|_| "main".to_string()).collect();
        let threads: Vec<_> = thread_names
@ -642,8 +725,11 @@ impl Nac3 {
            let mut generator =
                ArtiqCodeGenerator::new("attributes_writeback".to_string(), size_t, self.time_fns);
-            let context = inkwell::context::Context::create();
+            let context = Context::create();
            let module = context.create_module("attributes_writeback");
            let target_machine = self.llvm_options.create_target_machine().unwrap();
            module.set_data_layout(&target_machine.get_target_data().get_data_layout());
            module.set_triple(&target_machine.get_triple());
            let builder = context.create_builder();
            let (_, module, _) = gen_func_impl(
                &context,
@ -662,7 +748,7 @@ impl Nac3 {
            membuffer.lock().push(buffer);
        });
-        let context = inkwell::context::Context::create();
+        // Link all modules into `main`.
        let buffers = membuffers.lock();
        let main = context
            .create_module_from_ir(MemoryBuffer::create_from_memory_range(&buffers[0], "main"))
@ -691,8 +777,7 @@ impl Nac3 {
            )
            .unwrap();
-        main.link_in_module(load_irrt(&context))
+        main.link_in_module(irrt).map_err(|err| CompileError::new_err(err.to_string()))?;
            .map_err(|err| CompileError::new_err(err.to_string()))?;
        let mut function_iter = main.get_first_function();
        while let Some(func) = function_iter {
@ -778,6 +863,41 @@ impl Nac3 {
    }
 }
 /// Retrieves the Name.id from a decorator, supports decorators with arguments.
 fn decorator_id_string(decorator: &Located<ExprKind>) -> Option<String> {
    if let ExprKind::Name { id, .. } = decorator.node {
        // Bare decorator
        return Some(id.to_string());
    } else if let ExprKind::Call { func, .. } = &decorator.node {
        // Decorators that are calls (e.g. "@rpc()") have Call for the node,
        // need to extract the id from within.
        if let ExprKind::Name { id, .. } = func.node {
            return Some(id.to_string());
        }
    }
    None
 }
 /// Retrieves flags from a decorator, if any.
 fn decorator_get_flags(decorator: &Located<ExprKind>) -> Vec<Constant> {
    let mut flags = vec![];
    if let ExprKind::Call { keywords, .. } = &decorator.node {
        for keyword in keywords {
            if keyword.node.arg != Some("flags".into()) {
                continue;
            }
            if let ExprKind::Set { elts } = &keyword.node.value.node {
                for elt in elts {
                    if let ExprKind::Constant { value, .. } = &elt.node {
                        flags.push(value.clone());
                    }
                }
            }
        }
    }
    flags
 }
 fn link_with_lld(elf_filename: String, obj_filename: String) -> PyResult<()> {
    let linker_args = vec![
        "-shared".to_string(),
@ -847,7 +967,7 @@ impl Nac3 {
            Isa::RiscV32IMA => &timeline::NOW_PINNING_TIME_FNS,
            Isa::CortexA9 | Isa::Host => &timeline::EXTERN_TIME_FNS,
        };
-        let primitive: PrimitiveStore = TopLevelComposer::make_primitives(isa.get_size_type()).0;
+        let (primitive, _) = TopLevelComposer::make_primitives(isa.get_size_type());
        let builtins = vec![
            (
                "now_mu".into(),
@ -863,6 +983,7 @@ impl Nac3 {
                        name: "t".into(),
                        ty: primitive.int64,
                        default_value: None,
                        is_vararg: false,
                    }],
                    ret: primitive.none,
                    vars: VarMap::new(),
@ -882,6 +1003,7 @@ impl Nac3 {
                        name: "dt".into(),
                        ty: primitive.int64,
                        default_value: None,
                        is_vararg: false,
                    }],
                    ret: primitive.none,
                    vars: VarMap::new(),
--- a/nac3artiq/src/symbol_resolver.rs
+++ b/nac3artiq/src/symbol_resolver.rs
@ -1,9 +1,12 @@
-use inkwell::{
+use crate::PrimitivePythonId;
 use itertools::Itertools;
 use nac3core::inkwell::{
    module::Linkage,
    types::{BasicType, BasicTypeEnum},
    values::BasicValueEnum,
    AddressSpace,
 };
-use itertools::Itertools;
+use nac3core::nac3parser::ast::{self, StrRef};
 use nac3core::{
    codegen::{
        classes::{NDArrayType, ProxyType},
@ -20,8 +23,7 @@ use nac3core::{
        typedef::{into_var_map, iter_type_vars, Type, TypeEnum, TypeVar, Unifier, VarMap},
    },
 };
-use nac3parser::ast::{self, StrRef};
+use parking_lot::RwLock;
 use parking_lot::{Mutex, RwLock};
 use pyo3::{
    types::{PyDict, PyTuple},
    PyAny, PyObject, PyResult, Python,
@ -34,8 +36,6 @@ use std::{
    },
 };
 use crate::PrimitivePythonId;
 pub enum PrimitiveValue {
    I32(i32),
    I64(i64),
@ -79,7 +79,6 @@ pub struct InnerResolver {
    pub id_to_primitive: RwLock<HashMap<u64, PrimitiveValue>>,
    pub field_to_val: RwLock<HashMap<ResolverField, Option<PyFieldHandle>>>,
    pub global_value_ids: Arc<RwLock<HashMap<u64, PyObject>>>,
    pub class_names: Mutex<HashMap<StrRef, Type>>,
    pub pyid_to_def: Arc<RwLock<HashMap<u64, DefinitionId>>>,
    pub pyid_to_type: Arc<RwLock<HashMap<u64, Type>>>,
    pub primitive_ids: PrimitivePythonId,
@ -133,6 +132,8 @@ impl StaticValue for PythonValue {
                        format!("{}_const", self.id).as_str(),
                    );
                    global.set_constant(true);
                    // Set linkage of global to private to avoid name collisions
                    global.set_linkage(Linkage::Private);
                    global.set_initializer(&ctx.ctx.const_struct(
                        &[ctx.ctx.i32_type().const_int(u64::from(id), false).into()],
                        false,
@ -163,7 +164,7 @@ impl StaticValue for PythonValue {
                PrimitiveValue::Bool(val) => {
                    ctx.ctx.i8_type().const_int(u64::from(*val), false).into()
                }
-                PrimitiveValue::Str(val) => ctx.ctx.const_string(val.as_bytes(), true).into(),
+                PrimitiveValue::Str(val) => ctx.gen_string(generator, val).into(),
            });
        }
        if let Some(global) = ctx.module.get_global(&self.id.to_string()) {
@ -329,8 +330,19 @@ impl InnerResolver {
            Ok(Ok((primitives.exception, true)))
        } else if ty_id == self.primitive_ids.list {
            // do not handle type var param and concrete check here
            let list_tvar = if let TypeEnum::TObj { obj_id, params, .. } =
                &*unifier.get_ty_immutable(primitives.list)
            {
                assert_eq!(*obj_id, PrimDef::List.id());
                iter_type_vars(params).nth(0).unwrap()
            } else {
                unreachable!()
            };
            let var = unifier.get_dummy_var().ty;
-            let list = unifier.add_ty(TypeEnum::TList { ty: var });
+            let list = unifier
                .subst(primitives.list, &into_var_map([TypeVar { id: list_tvar.id, ty: var }]))
                .unwrap();
            Ok(Ok((list, false)))
        } else if ty_id == self.primitive_ids.ndarray {
            // do not handle type var param and concrete check here
@ -340,7 +352,7 @@ impl InnerResolver {
            Ok(Ok((ndarray, false)))
        } else if ty_id == self.primitive_ids.tuple {
            // do not handle type var param and concrete check here
-            Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: vec![] }), false)))
+            Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: vec![], is_vararg_ctx: false }), false)))
        } else if ty_id == self.primitive_ids.option {
            Ok(Ok((primitives.option, false)))
        } else if ty_id == self.primitive_ids.none {
@ -460,7 +472,7 @@ impl InnerResolver {
                };
            match &*unifier.get_ty(origin_ty) {
-                TypeEnum::TList { .. } => {
+                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
                    if args.len() == 1 {
                        let ty = match self.get_pyty_obj_type(
                            py,
@ -477,7 +489,21 @@ impl InnerResolver {
                                "type list should take concrete parameters in typevar range".into(),
                            ));
                        }
-                        Ok(Ok((unifier.add_ty(TypeEnum::TList { ty: ty.0 }), true)))
+                        let list_tvar = if let TypeEnum::TObj { obj_id, params, .. } =
                            &*unifier.get_ty_immutable(primitives.list)
                        {
                            assert_eq!(*obj_id, PrimDef::List.id());
                            iter_type_vars(params).nth(0).unwrap()
                        } else {
                            unreachable!()
                        };
                        let list = unifier
                            .subst(
                                primitives.list,
                                &into_var_map([TypeVar { id: list_tvar.id, ty: ty.0 }]),
                            )
                            .unwrap();
                        Ok(Ok((list, true)))
                    } else {
                        return Ok(Err(format!(
                            "type list needs exactly 1 type parameters, found {}",
@ -530,7 +556,10 @@ impl InnerResolver {
                            Err(err) => return Ok(Err(err)),
                            _ => return Ok(Err("tuple type needs at least 1 type parameters".to_string()))
                        };
-                    Ok(Ok((unifier.add_ty(TypeEnum::TTuple { ty: args }), true)))
+                    Ok(Ok((
                        unifier.add_ty(TypeEnum::TTuple { ty: args, is_vararg_ctx: false }),
                        true,
                    )))
                }
                TypeEnum::TObj { params, obj_id, .. } => {
                    let subst = {
@ -627,7 +656,9 @@ impl InnerResolver {
        let pyid_to_def = self.pyid_to_def.read();
        let constructor_ty = pyid_to_def.get(&py_obj_id).and_then(|def_id| {
            defs.iter().find_map(|def| {
-                if let TopLevelDef::Class { object_id, methods, constructor, .. } = &*def.read() {
+                if let Some(rear_guard) = def.try_read() {
                    if let TopLevelDef::Class { object_id, methods, constructor, .. } = &*rear_guard
                    {
                        if object_id == def_id
                            && constructor.is_some()
                            && methods.iter().any(|(s, _, _)| s == &"__init__".into())
@ -635,6 +666,7 @@ impl InnerResolver {
                            return *constructor;
                        }
                    }
                }
                None
            })
        });
@ -664,15 +696,38 @@ impl InnerResolver {
            primitives,
        )? {
            Ok(s) => s,
-            Err(e) => return Ok(Err(e)),
+            Err(e) => {
                // Allow access to Class Attributes of Classes without having to initialize Objects
                if self.pyid_to_def.read().contains_key(&py_obj_id) {
                    if let Some(def_id) = self.pyid_to_def.read().get(&py_obj_id).copied() {
                        let def = defs[def_id.0].read();
                        let TopLevelDef::Class { object_id, .. } = &*def else {
                            // only object is supported, functions are not supported
                            unreachable!("function type is not supported, should not be queried")
                        };
                        let ty = TypeEnum::TObj {
                            obj_id: *object_id,
                            params: VarMap::new(),
                            fields: HashMap::new(),
                        };
                        (unifier.add_ty(ty), true)
                    } else {
                        return Ok(Err(e));
                    }
                } else {
                    return Ok(Err(e));
                }
            }
        };
        match (&*unifier.get_ty(extracted_ty), inst_check) {
            // do the instantiation for these four types
-            (TypeEnum::TList { ty }, false) => {
+            (TypeEnum::TObj { obj_id, params, .. }, false) if *obj_id == PrimDef::List.id() => {
                let ty = iter_type_vars(params).nth(0).unwrap().ty;
                let len: usize = self.helper.len_fn.call1(py, (obj,))?.extract(py)?;
                if len == 0 {
                    assert!(matches!(
-                        &*unifier.get_ty(*ty),
+                        &*unifier.get_ty(ty),
                        TypeEnum::TVar { fields: None, range, .. }
                            if range.is_empty()
                    ));
@ -681,8 +736,25 @@ impl InnerResolver {
                    let actual_ty =
                        self.get_list_elem_type(py, obj, len, unifier, defs, primitives)?;
                    match actual_ty {
-                        Ok(t) => match unifier.unify(*ty, t) {
+                        Ok(t) => match unifier.unify(ty, t) {
-                            Ok(()) => Ok(Ok(unifier.add_ty(TypeEnum::TList { ty: *ty }))),
+                            Ok(()) => {
                                let list_tvar = if let TypeEnum::TObj { obj_id, params, .. } =
                                    &*unifier.get_ty_immutable(primitives.list)
                                {
                                    assert_eq!(*obj_id, PrimDef::List.id());
                                    iter_type_vars(params).nth(0).unwrap()
                                } else {
                                    unreachable!()
                                };
                                let list = unifier
                                    .subst(
                                        primitives.list,
                                        &into_var_map([TypeVar { id: list_tvar.id, ty }]),
                                    )
                                    .unwrap();
                                Ok(Ok(list))
                            }
                            Err(e) => Ok(Err(format!(
                                "type error ({}) for the list",
                                e.to_display(unifier)
@ -729,7 +801,9 @@ impl InnerResolver {
                    .map(|elem| self.get_obj_type(py, elem, unifier, defs, primitives))
                    .collect();
                let types = types?;
-                Ok(types.map(|types| unifier.add_ty(TypeEnum::TTuple { ty: types })))
+                Ok(types.map(|types| {
                    unifier.add_ty(TypeEnum::TTuple { ty: types, is_vararg_ctx: false })
                }))
            }
            // special handling for option type since its class member layout in python side
            // is special and cannot be mapped directly to a nac3 type as below
@ -904,7 +978,7 @@ impl InnerResolver {
        } else if ty_id == self.primitive_ids.string || ty_id == self.primitive_ids.np_str_ {
            let val: String = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::Str(val.clone()));
-            Ok(Some(ctx.ctx.const_string(val.as_bytes(), true).into()))
+            Ok(Some(ctx.gen_string(generator, val).into()))
        } else if ty_id == self.primitive_ids.float || ty_id == self.primitive_ids.float64 {
            let val: f64 = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::F64(val));
@ -917,15 +991,21 @@ impl InnerResolver {
            }
            let len: usize = self.helper.len_fn.call1(py, (obj,))?.extract(py)?;
-            let elem_ty = if let TypeEnum::TList { ty } =
+            let elem_ty = match ctx.unifier.get_ty_immutable(expected_ty).as_ref() {
-                ctx.unifier.get_ty_immutable(expected_ty).as_ref()
+                TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
-            {
+                    iter_type_vars(params).nth(0).unwrap().ty
-                *ty
+                }
-            } else {
+                _ => unreachable!("must be list"),
                unreachable!("must be list")
            };
            let ty = ctx.get_llvm_type(generator, elem_ty);
            let size_t = generator.get_size_type(ctx.ctx);
            let ty = if len == 0
                && matches!(&*ctx.unifier.get_ty_immutable(elem_ty), TypeEnum::TVar { .. })
            {
                // The default type for zero-length lists of unknown element type is size_t
                size_t.into()
            } else {
                ctx.get_llvm_type(generator, elem_ty)
            };
            let arr_ty = ctx
                .ctx
                .struct_type(&[ty.ptr_type(AddressSpace::default()).into(), size_t.into()], false);
@ -1129,7 +1209,9 @@ impl InnerResolver {
            Ok(Some(ndarray.as_pointer_value().into()))
        } else if ty_id == self.primitive_ids.tuple {
            let expected_ty_enum = ctx.unifier.get_ty_immutable(expected_ty);
-            let TypeEnum::TTuple { ty } = expected_ty_enum.as_ref() else { unreachable!() };
+            let TypeEnum::TTuple { ty, is_vararg_ctx: false } = expected_ty_enum.as_ref() else {
                unreachable!()
            };
            let tup_tys = ty.iter();
            let elements: &PyTuple = obj.downcast()?;
--- a/nac3artiq/src/timeline.rs
+++ b/nac3artiq/src/timeline.rs
@ -1,9 +1,9 @@
-use inkwell::{
+use itertools::Either;
 use nac3core::codegen::CodeGenContext;
 use nac3core::inkwell::{
    values::{BasicValueEnum, CallSiteValue},
    AddressSpace, AtomicOrdering,
 };
 use itertools::Either;
 use nac3core::codegen::CodeGenContext;
 /// Functions for manipulating the timeline.
 pub trait TimeFns {
@ -31,7 +31,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
@ -80,7 +80,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
@ -109,7 +109,7 @@ impl TimeFns for NowPinningTimeFns64 {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
@ -207,7 +207,7 @@ impl TimeFns for NowPinningTimeFns {
            .unwrap_or_else(|| ctx.module.add_global(i64_type, None, "now"));
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
@ -258,7 +258,7 @@ impl TimeFns for NowPinningTimeFns {
        let time_lo = ctx.builder.build_int_truncate(time, i32_type, "time.lo").unwrap();
        let now_hiptr = ctx
            .builder
-            .build_bitcast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
+            .build_bit_cast(now, i32_type.ptr_type(AddressSpace::default()), "now.hi.addr")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
--- a/nac3ast/Cargo.toml
+++ b/nac3ast/Cargo.toml
@ -10,7 +10,7 @@ constant-optimization = ["fold"]
 fold = []
 [dependencies]
-lazy_static = "1.4"
+lazy_static = "1.5"
 parking_lot = "0.12"
 string-interner = "0.17"
 fxhash = "0.2"
--- a/nac3core/Cargo.toml
+++ b/nac3core/Cargo.toml
@ -4,6 +4,9 @@ version = "0.1.0"
 authors = ["M-Labs"]
 edition = "2021"
 [features]
 no-escape-analysis = []
 [dependencies]
 itertools = "0.13"
 crossbeam = "0.8"
@ -11,13 +14,13 @@ indexmap = "2.2"
 parking_lot = "0.12"
 rayon = "1.8"
 nac3parser = { path = "../nac3parser" }
-strum = "0.26.2"
+strum = "0.26"
-strum_macros = "0.26.4"
+strum_macros = "0.26"
 [dependencies.inkwell]
-version = "0.4"
+version = "0.5"
 default-features = false
-features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
+features = ["llvm14-0-prefer-dynamic", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
 [dev-dependencies]
 test-case = "1.2.0"
--- a/nac3core/build.rs
+++ b/nac3core/build.rs
@ -8,33 +8,50 @@ use std::{
 };
 fn main() {
-    const FILE: &str = "src/codegen/irrt/irrt.c";
+    let out_dir = env::var("OUT_DIR").unwrap();
    let out_dir = Path::new(&out_dir);
    let irrt_dir = Path::new("irrt");
    let irrt_cpp_path = irrt_dir.join("irrt.cpp");
    /*
     * HACK: Sadly, clang doesn't let us emit generic LLVM bitcode.
     * Compiling for WASM32 and filtering the output with regex is the closest we can get.
     */
-    let flags: &[&str] = &[
+    let mut flags: Vec<&str> = vec![
        "--target=wasm32",
-        FILE,
+        "-x",
        "c++",
        "-std=c++20",
        "-fno-discard-value-names",
-        match env::var("PROFILE").as_deref() {
+        "-fno-exceptions",
-            Ok("debug") => "-O0",
+        "-fno-rtti",
            Ok("release") => "-O3",
            flavor => panic!("Unknown or missing build flavor {flavor:?}"),
        },
        "-emit-llvm",
        "-S",
        "-Wall",
        "-Wextra",
        "-o",
        "-",
        "-I",
        irrt_dir.to_str().unwrap(),
        irrt_cpp_path.to_str().unwrap(),
    ];
-    println!("cargo:rerun-if-changed={FILE}");
+    match env::var("PROFILE").as_deref() {
-    let out_dir = env::var("OUT_DIR").unwrap();
+        Ok("debug") => {
-    let out_path = Path::new(&out_dir);
+            flags.push("-O0");
            flags.push("-DIRRT_DEBUG_ASSERT");
        }
        Ok("release") => {
            flags.push("-O3");
        }
        flavor => panic!("Unknown or missing build flavor {flavor:?}"),
    }
    // Tell Cargo to rerun if any file under `irrt_dir` (recursive) changes
    println!("cargo:rerun-if-changed={}", irrt_dir.to_str().unwrap());
    // Compile IRRT and capture the LLVM IR output
    let output = Command::new("clang-irrt")
        .args(flags)
        .output()
@ -48,7 +65,17 @@ fn main() {
    let output = std::str::from_utf8(&output.stdout).unwrap().replace("\r\n", "\n");
    let mut filtered_output = String::with_capacity(output.len());
-    let regex_filter = Regex::new(r"(?ms:^define.*?\}$)|(?m:^declare.*?$)").unwrap();
+    // Filter out irrelevant IR
    //
    // Regex:
    // - `(?ms:^define.*?\}$)` captures LLVM `define` blocks
    // - `(?m:^declare.*?$)` captures LLVM `declare` lines
    // - `(?m:^%.+?=\s*type\s*\{.+?\}$)` captures LLVM `type` declarations
    // - `(?m:^@.+?=.+$)` captures global constants
    let regex_filter = Regex::new(
        r"(?ms:^define.*?\}$)|(?m:^declare.*?$)|(?m:^%.+?=\s*type\s*\{.+?\}$)|(?m:^@.+?=.+$)",
    )
    .unwrap();
    for f in regex_filter.captures_iter(&output) {
        assert_eq!(f.len(), 1);
        filtered_output.push_str(&f[0]);
@ -59,18 +86,22 @@ fn main() {
        .unwrap()
        .replace_all(&filtered_output, "");
-    println!("cargo:rerun-if-env-changed=DEBUG_DUMP_IRRT");
+    // For debugging
-    if env::var("DEBUG_DUMP_IRRT").is_ok() {
+    // Doing `DEBUG_DUMP_IRRT=1 cargo build -p nac3core` dumps the LLVM IR generated
-        let mut file = File::create(out_path.join("irrt.ll")).unwrap();
+    const DEBUG_DUMP_IRRT: &str = "DEBUG_DUMP_IRRT";
    println!("cargo:rerun-if-env-changed={DEBUG_DUMP_IRRT}");
    if env::var(DEBUG_DUMP_IRRT).is_ok() {
        let mut file = File::create(out_dir.join("irrt.ll")).unwrap();
        file.write_all(output.as_bytes()).unwrap();
-        let mut file = File::create(out_path.join("irrt-filtered.ll")).unwrap();
+
        let mut file = File::create(out_dir.join("irrt-filtered.ll")).unwrap();
        file.write_all(filtered_output.as_bytes()).unwrap();
    }
    let mut llvm_as = Command::new("llvm-as-irrt")
        .stdin(Stdio::piped())
        .arg("-o")
-        .arg(out_path.join("irrt.bc"))
+        .arg(out_dir.join("irrt.bc"))
        .spawn()
        .unwrap();
    llvm_as.stdin.as_mut().unwrap().write_all(filtered_output.as_bytes()).unwrap();
--- a/nac3core/irrt/irrt.cpp
+++ b/nac3core/irrt/irrt.cpp
@ -0,0 +1,6 @@
 #include "irrt/exception.hpp"
 #include "irrt/int_types.hpp"
 #include "irrt/list.hpp"
 #include "irrt/math.hpp"
 #include "irrt/ndarray.hpp"
 #include "irrt/slice.hpp"
--- a/nac3core/irrt/irrt/cslice.hpp
+++ b/nac3core/irrt/irrt/cslice.hpp
@ -0,0 +1,9 @@
 #pragma once
 #include "irrt/int_types.hpp"
 template<typename SizeT>
 struct CSlice {
    uint8_t* base;
    SizeT len;
 };
--- a/nac3core/irrt/irrt/debug.hpp
+++ b/nac3core/irrt/irrt/debug.hpp
@ -0,0 +1,25 @@
 #pragma once
 // Set in nac3core/build.rs
 #ifdef IRRT_DEBUG_ASSERT
 #define IRRT_DEBUG_ASSERT_BOOL true
 #else
 #define IRRT_DEBUG_ASSERT_BOOL false
 #endif
 #define raise_debug_assert(SizeT, msg, param1, param2, param3) \
    raise_exception(SizeT, EXN_ASSERTION_ERROR, "IRRT debug assert failed: " msg, param1, param2, param3)
 #define debug_assert_eq(SizeT, lhs, rhs)                                           \
    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
        if ((lhs) != (rhs)) {                                                      \
            raise_debug_assert(SizeT, "LHS = {0}. RHS = {1}", lhs, rhs, NO_PARAM); \
        }                                                                          \
    }
 #define debug_assert(SizeT, expr)                                                  \
    if constexpr (IRRT_DEBUG_ASSERT_BOOL) {                                        \
        if (!(expr)) {                                                             \
            raise_debug_assert(SizeT, "Got false.", NO_PARAM, NO_PARAM, NO_PARAM); \
        }                                                                          \
    }
--- a/nac3core/irrt/irrt/exception.hpp
+++ b/nac3core/irrt/irrt/exception.hpp
@ -0,0 +1,82 @@
 #pragma once
 #include "irrt/cslice.hpp"
 #include "irrt/int_types.hpp"
 /**
 * @brief The int type of ARTIQ exception IDs.
 */
 typedef int32_t ExceptionId;
 /*
 * Set of exceptions C++ IRRT can use.
 * Must be synchronized with `setup_irrt_exceptions` in `nac3core/src/codegen/irrt/mod.rs`.
 */
 extern "C" {
 ExceptionId EXN_INDEX_ERROR;
 ExceptionId EXN_VALUE_ERROR;
 ExceptionId EXN_ASSERTION_ERROR;
 ExceptionId EXN_TYPE_ERROR;
 }
 /**
 * @brief Extern function to `__nac3_raise`
 *
 * The parameter `err` could be `Exception<int32_t>` or `Exception<int64_t>`. The caller
 * must make sure to pass `Exception`s with the correct `SizeT` depending on the `size_t` of the runtime.
 */
 extern "C" void __nac3_raise(void* err);
 namespace {
 /**
 * @brief NAC3's Exception struct
 */
 template<typename SizeT>
 struct Exception {
    ExceptionId id;
    CSlice<SizeT> filename;
    int32_t line;
    int32_t column;
    CSlice<SizeT> function;
    CSlice<SizeT> msg;
    int64_t params[3];
 };
 constexpr int64_t NO_PARAM = 0;
 template<typename SizeT>
 void _raise_exception_helper(ExceptionId id,
                             const char* filename,
                             int32_t line,
                             const char* function,
                             const char* msg,
                             int64_t param0,
                             int64_t param1,
                             int64_t param2) {
    Exception<SizeT> e = {
        .id = id,
        .filename = {.base = reinterpret_cast<const uint8_t*>(filename), .len = __builtin_strlen(filename)},
        .line = line,
        .column = 0,
        .function = {.base = reinterpret_cast<const uint8_t*>(function), .len = __builtin_strlen(function)},
        .msg = {.base = reinterpret_cast<const uint8_t*>(msg), .len = __builtin_strlen(msg)},
    };
    e.params[0] = param0;
    e.params[1] = param1;
    e.params[2] = param2;
    __nac3_raise(reinterpret_cast<void*>(&e));
    __builtin_unreachable();
 }
 /**
 * @brief Raise an exception with location details (location in the IRRT source files).
 * @param SizeT The runtime `size_t` type.
 * @param id The ID of the exception to raise.
 * @param msg A global constant C-string of the error message.
 *
 * `param0` to `param2` are optional format arguments of `msg`. They should be set to
 * `NO_PARAM` to indicate they are unused.
 */
 #define raise_exception(SizeT, id, msg, param0, param1, param2) \
    _raise_exception_helper<SizeT>(id, __FILE__, __LINE__, __FUNCTION__, msg, param0, param1, param2)
 }  // namespace
--- a/nac3core/irrt/irrt/int_types.hpp
+++ b/nac3core/irrt/irrt/int_types.hpp
@ -0,0 +1,22 @@
 #pragma once
 #if __STDC_VERSION__ >= 202000
 using int8_t = _BitInt(8);
 using uint8_t = unsigned _BitInt(8);
 using int32_t = _BitInt(32);
 using uint32_t = unsigned _BitInt(32);
 using int64_t = _BitInt(64);
 using uint64_t = unsigned _BitInt(64);
 #else
 using int8_t = _ExtInt(8);
 using uint8_t = unsigned _ExtInt(8);
 using int32_t = _ExtInt(32);
 using uint32_t = unsigned _ExtInt(32);
 using int64_t = _ExtInt(64);
 using uint64_t = unsigned _ExtInt(64);
 #endif
 // NDArray indices are always `uint32_t`.
 using NDIndex = uint32_t;
 // The type of an index or a value describing the length of a range/slice is always `int32_t`.
 using SliceIndex = int32_t;
--- a/nac3core/irrt/irrt/list.hpp
+++ b/nac3core/irrt/irrt/list.hpp
@ -0,0 +1,75 @@
 #pragma once
 #include "irrt/int_types.hpp"
 #include "irrt/math_util.hpp"
 extern "C" {
 // Handle list assignment and dropping part of the list when
 // both dest_step and src_step are +1.
 // - All the index must *not* be out-of-bound or negative,
 // - The end index is *inclusive*,
 // - The length of src and dest slice size should already
 // be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
 SliceIndex __nac3_list_slice_assign_var_size(SliceIndex dest_start,
                                             SliceIndex dest_end,
                                             SliceIndex dest_step,
                                             uint8_t* dest_arr,
                                             SliceIndex dest_arr_len,
                                             SliceIndex src_start,
                                             SliceIndex src_end,
                                             SliceIndex src_step,
                                             uint8_t* src_arr,
                                             SliceIndex src_arr_len,
                                             const SliceIndex size) {
    /* if dest_arr_len == 0, do nothing since we do not support extending list */
    if (dest_arr_len == 0)
        return dest_arr_len;
    /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
    if (src_step == dest_step && dest_step == 1) {
        const SliceIndex src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
        const SliceIndex dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
        if (src_len > 0) {
            __builtin_memmove(dest_arr + dest_start * size, src_arr + src_start * size, src_len * size);
        }
        if (dest_len > 0) {
            /* dropping */
            __builtin_memmove(dest_arr + (dest_start + src_len) * size, dest_arr + (dest_end + 1) * size,
                              (dest_arr_len - dest_end - 1) * size);
        }
        /* shrink size */
        return dest_arr_len - (dest_len - src_len);
    }
    /* if two range overlaps, need alloca */
    uint8_t need_alloca = (dest_arr == src_arr)
                          && !(max(dest_start, dest_end) < min(src_start, src_end)
                               || max(src_start, src_end) < min(dest_start, dest_end));
    if (need_alloca) {
        uint8_t* tmp = reinterpret_cast<uint8_t*>(__builtin_alloca(src_arr_len * size));
        __builtin_memcpy(tmp, src_arr, src_arr_len * size);
        src_arr = tmp;
    }
    SliceIndex src_ind = src_start;
    SliceIndex dest_ind = dest_start;
    for (; (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end); src_ind += src_step, dest_ind += dest_step) {
        /* for constant optimization */
        if (size == 1) {
            __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
        } else if (size == 4) {
            __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
        } else if (size == 8) {
            __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
        } else {
            /* memcpy for var size, cannot overlap after previous alloca */
            __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
        }
    }
    /* only dest_step == 1 can we shrink the dest list. */
    /* size should be ensured prior to calling this function */
    if (dest_step == 1 && dest_end >= dest_start) {
        __builtin_memmove(dest_arr + dest_ind * size, dest_arr + (dest_end + 1) * size,
                          (dest_arr_len - dest_end - 1) * size);
        return dest_arr_len - (dest_end - dest_ind) - 1;
    }
    return dest_arr_len;
 }
 }  // extern "C"
--- a/nac3core/irrt/irrt/math.hpp
+++ b/nac3core/irrt/irrt/math.hpp
@ -0,0 +1,93 @@
 #pragma once
 namespace {
 // adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
 // need to make sure `exp >= 0` before calling this function
 template<typename T>
 T __nac3_int_exp_impl(T base, T exp) {
    T res = 1;
    /* repeated squaring method */
    do {
        if (exp & 1) {
            res *= base; /* for n odd */
        }
        exp >>= 1;
        base *= base;
    } while (exp);
    return res;
 }
 }  // namespace
 #define DEF_nac3_int_exp_(T)                   \
    T __nac3_int_exp_##T(T base, T exp) {      \
        return __nac3_int_exp_impl(base, exp); \
    }
 extern "C" {
 // Putting semicolons here to make clang-format not reformat this into
 // a stair shape.
 DEF_nac3_int_exp_(int32_t);
 DEF_nac3_int_exp_(int64_t);
 DEF_nac3_int_exp_(uint32_t);
 DEF_nac3_int_exp_(uint64_t);
 int32_t __nac3_isinf(double x) {
    return __builtin_isinf(x);
 }
 int32_t __nac3_isnan(double x) {
    return __builtin_isnan(x);
 }
 double tgamma(double arg);
 double __nac3_gamma(double z) {
    // Handling for denormals
    //     | x                 | Python gamma(x) | C tgamma(x) |
    // --- | ----------------- | --------------- | ----------- |
    // (1) | nan               | nan             | nan         |
    // (2) | -inf              | -inf            | inf         |
    // (3) | inf               | inf             | inf         |
    // (4) | 0.0               | inf             | inf         |
    // (5) | {-1.0, -2.0, ...} | inf             | nan         |
    // (1)-(3)
    if (__builtin_isinf(z) || __builtin_isnan(z)) {
        return z;
    }
    double v = tgamma(z);
    // (4)-(5)
    return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
 }
 double lgamma(double arg);
 double __nac3_gammaln(double x) {
    // libm's handling of value overflows differs from scipy:
    // - scipy: gammaln(-inf) -> -inf
    // - libm : lgamma(-inf) -> inf
    if (__builtin_isinf(x)) {
        return x;
    }
    return lgamma(x);
 }
 double j0(double x);
 double __nac3_j0(double x) {
    // libm's handling of value overflows differs from scipy:
    // - scipy: j0(inf) -> nan
    // - libm : j0(inf) -> 0.0
    if (__builtin_isinf(x)) {
        return __builtin_nan("");
    }
    return j0(x);
 }
 }
--- a/nac3core/irrt/irrt/math_util.hpp
+++ b/nac3core/irrt/irrt/math_util.hpp
@ -0,0 +1,13 @@
 #pragma once
 namespace {
 template<typename T>
 const T& max(const T& a, const T& b) {
    return a > b ? a : b;
 }
 template<typename T>
 const T& min(const T& a, const T& b) {
    return a > b ? b : a;
 }
 }  // namespace
--- a/nac3core/irrt/irrt/ndarray.hpp
+++ b/nac3core/irrt/irrt/ndarray.hpp
@ -0,0 +1,144 @@
 #pragma once
 #include "irrt/int_types.hpp"
 namespace {
 template<typename SizeT>
 SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
    __builtin_assume(end_idx <= list_len);
    SizeT num_elems = 1;
    for (SizeT i = begin_idx; i < end_idx; ++i) {
        SizeT val = list_data[i];
        __builtin_assume(val > 0);
        num_elems *= val;
    }
    return num_elems;
 }
 template<typename SizeT>
 void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndex* idxs) {
    SizeT stride = 1;
    for (SizeT dim = 0; dim < num_dims; dim++) {
        SizeT i = num_dims - dim - 1;
        __builtin_assume(dims[i] > 0);
        idxs[i] = (index / stride) % dims[i];
        stride *= dims[i];
    }
 }
 template<typename SizeT>
 SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims, SizeT num_dims, const NDIndex* indices, SizeT num_indices) {
    SizeT idx = 0;
    SizeT stride = 1;
    for (SizeT i = 0; i < num_dims; ++i) {
        SizeT ri = num_dims - i - 1;
        if (ri < num_indices) {
            idx += stride * indices[ri];
        }
        __builtin_assume(dims[i] > 0);
        stride *= dims[ri];
    }
    return idx;
 }
 template<typename SizeT>
 void __nac3_ndarray_calc_broadcast_impl(const SizeT* lhs_dims,
                                        SizeT lhs_ndims,
                                        const SizeT* rhs_dims,
                                        SizeT rhs_ndims,
                                        SizeT* out_dims) {
    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
    for (SizeT i = 0; i < max_ndims; ++i) {
        const SizeT* lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
        const SizeT* rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
        SizeT* out_dim = &out_dims[max_ndims - i - 1];
        if (lhs_dim_sz == nullptr) {
            *out_dim = *rhs_dim_sz;
        } else if (rhs_dim_sz == nullptr) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == 1) {
            *out_dim = *rhs_dim_sz;
        } else if (*rhs_dim_sz == 1) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == *rhs_dim_sz) {
            *out_dim = *lhs_dim_sz;
        } else {
            __builtin_unreachable();
        }
    }
 }
 template<typename SizeT>
 void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
                                            SizeT src_ndims,
                                            const NDIndex* in_idx,
                                            NDIndex* out_idx) {
    for (SizeT i = 0; i < src_ndims; ++i) {
        SizeT src_i = src_ndims - i - 1;
        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
    }
 }
 }  // namespace
 extern "C" {
 uint32_t __nac3_ndarray_calc_size(const uint32_t* list_data, uint32_t list_len, uint32_t begin_idx, uint32_t end_idx) {
    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
 }
 uint64_t
 __nac3_ndarray_calc_size64(const uint64_t* list_data, uint64_t list_len, uint64_t begin_idx, uint64_t end_idx) {
    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
 }
 void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndex* idxs) {
    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
 }
 void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndex* idxs) {
    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
 }
 uint32_t
 __nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndex* indices, uint32_t num_indices) {
    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
 }
 uint64_t
 __nac3_ndarray_flatten_index64(const uint64_t* dims, uint64_t num_dims, const NDIndex* indices, uint64_t num_indices) {
    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
 }
 void __nac3_ndarray_calc_broadcast(const uint32_t* lhs_dims,
                                   uint32_t lhs_ndims,
                                   const uint32_t* rhs_dims,
                                   uint32_t rhs_ndims,
                                   uint32_t* out_dims) {
    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
 }
 void __nac3_ndarray_calc_broadcast64(const uint64_t* lhs_dims,
                                     uint64_t lhs_ndims,
                                     const uint64_t* rhs_dims,
                                     uint64_t rhs_ndims,
                                     uint64_t* out_dims) {
    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
 }
 void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
                                       uint32_t src_ndims,
                                       const NDIndex* in_idx,
                                       NDIndex* out_idx) {
    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
 }
 void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
                                         uint64_t src_ndims,
                                         const NDIndex* in_idx,
                                         NDIndex* out_idx) {
    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
 }
 }
--- a/nac3core/irrt/irrt/slice.hpp
+++ b/nac3core/irrt/irrt/slice.hpp
@ -0,0 +1,28 @@
 #pragma once
 #include "irrt/int_types.hpp"
 extern "C" {
 SliceIndex __nac3_slice_index_bound(SliceIndex i, const SliceIndex len) {
    if (i < 0) {
        i = len + i;
    }
    if (i < 0) {
        return 0;
    } else if (i > len) {
        return len;
    }
    return i;
 }
 SliceIndex __nac3_range_slice_len(const SliceIndex start, const SliceIndex end, const SliceIndex step) {
    SliceIndex diff = end - start;
    if (diff > 0 && step > 0) {
        return ((diff - 1) / step) + 1;
    } else if (diff < 0 && step < 0) {
        return ((diff + 1) / step) + 1;
    } else {
        return 0;
    }
 }
 }
--- a/nac3core/src/codegen/builtin_fns.rs
+++ b/nac3core/src/codegen/builtin_fns.rs
@ -1,26 +1,94 @@
 use inkwell::types::BasicTypeEnum;
-use inkwell::values::BasicValueEnum;
+use inkwell::values::{BasicValue, BasicValueEnum, IntValue, PointerValue};
 use inkwell::{FloatPredicate, IntPredicate, OptimizationLevel};
 use itertools::Itertools;
-use crate::codegen::classes::{NDArrayValue, ProxyValue, UntypedArrayLikeAccessor};
+use crate::codegen::classes::{
    ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor,
    UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
 };
 use crate::codegen::expr::destructure_range;
 use crate::codegen::irrt::calculate_len_for_slice_range;
 use crate::codegen::macros::codegen_unreachable;
 use crate::codegen::numpy::ndarray_elementwise_unaryop_impl;
 use crate::codegen::stmt::gen_for_callback_incrementing;
 use crate::codegen::{extern_fns, irrt, llvm_intrinsics, numpy, CodeGenContext, CodeGenerator};
 use crate::toplevel::helper::PrimDef;
 use crate::toplevel::numpy::unpack_ndarray_var_tys;
-use crate::typecheck::typedef::Type;
+use crate::typecheck::typedef::{Type, TypeEnum};
 /// Shorthand for [`unreachable!()`] when a type of argument is not supported.
 ///
 /// The generated message will contain the function name and the name of the unsupported type.
 fn unsupported_type(ctx: &CodeGenContext<'_, '_>, fn_name: &str, tys: &[Type]) -> ! {
-    unreachable!(
+    codegen_unreachable!(
        ctx,
        "{fn_name}() not supported for '{}'",
        tys.iter().map(|ty| format!("'{}'", ctx.unifier.stringify(*ty))).join(", "),
    )
 }
 /// Invokes the `len` builtin function.
 pub fn call_len<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    n: (Type, BasicValueEnum<'ctx>),
 ) -> Result<IntValue<'ctx>, String> {
    let llvm_i32 = ctx.ctx.i32_type();
    let range_ty = ctx.primitives.range;
    let (arg_ty, arg) = n;
    Ok(if ctx.unifier.unioned(arg_ty, range_ty) {
        let arg = RangeValue::from_ptr_val(arg.into_pointer_value(), Some("range"));
        let (start, end, step) = destructure_range(ctx, arg);
        calculate_len_for_slice_range(generator, ctx, start, end, step)
    } else {
        match &*ctx.unifier.get_ty_immutable(arg_ty) {
            TypeEnum::TTuple { ty, .. } => llvm_i32.const_int(ty.len() as u64, false),
            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
                let zero = llvm_i32.const_zero();
                let len = ctx
                    .build_gep_and_load(
                        arg.into_pointer_value(),
                        &[zero, llvm_i32.const_int(1, false)],
                        None,
                    )
                    .into_int_value();
                ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
            }
            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
                let llvm_usize = generator.get_size_type(ctx.ctx);
                let arg = NDArrayValue::from_ptr_val(arg.into_pointer_value(), llvm_usize, None);
                let ndims = arg.dim_sizes().size(ctx, generator);
                ctx.make_assert(
                    generator,
                    ctx.builder
                        .build_int_compare(IntPredicate::NE, ndims, llvm_usize.const_zero(), "")
                        .unwrap(),
                    "0:TypeError",
                    "len() of unsized object",
                    [None, None, None],
                    ctx.current_loc,
                );
                let len = unsafe {
                    arg.dim_sizes().get_typed_unchecked(
                        ctx,
                        generator,
                        &llvm_usize.const_zero(),
                        None,
                    )
                };
                ctx.builder.build_int_truncate_or_bit_cast(len, llvm_i32, "len").unwrap()
            }
            _ => codegen_unreachable!(ctx),
        }
    })
 }
 /// Invokes the `int32` builtin function.
 pub fn call_int32<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
@ -31,7 +99,6 @@ pub fn call_int32<'ctx, G: CodeGenerator + ?Sized>(
    let llvm_usize = generator.get_size_type(ctx.ctx);
    let (n_ty, n) = n;
    Ok(match n {
        BasicValueEnum::IntValue(n) if matches!(n.get_type().get_bit_width(), 1 | 8) => {
            debug_assert!(ctx.unifier.unioned(n_ty, ctx.primitives.bool));
@ -419,7 +486,7 @@ pub fn call_numpy_round<'ctx, G: CodeGenerator + ?Sized>(
        BasicValueEnum::FloatValue(n) => {
            debug_assert!(ctx.unifier.unioned(n_ty, ctx.primitives.float));
-            llvm_intrinsics::call_float_roundeven(ctx, n, None).into()
+            llvm_intrinsics::call_float_rint(ctx, n, None).into()
        }
        BasicValueEnum::PointerValue(n)
@ -602,7 +669,7 @@ pub fn call_ceil<'ctx, G: CodeGenerator + ?Sized>(
                ret_elem_ty,
                None,
                NDArrayValue::from_ptr_val(n, llvm_usize, None),
-                |generator, ctx, val| call_floor(generator, ctx, (elem_ty, val), ret_elem_ty),
+                |generator, ctx, val| call_ceil(generator, ctx, (elem_ty, val), ret_elem_ty),
            )?;
            ndarray.as_base_value().into()
@ -661,90 +728,6 @@ pub fn call_min<'ctx>(
    }
 }
 /// Invokes the `np_min` builtin function.
 pub fn call_numpy_min<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    a: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_min";
    let llvm_usize = generator.get_size_type(ctx.ctx);
    let (a_ty, a) = a;
    Ok(match a {
        BasicValueEnum::IntValue(_) | BasicValueEnum::FloatValue(_) => {
            debug_assert!([
                ctx.primitives.bool,
                ctx.primitives.int32,
                ctx.primitives.uint32,
                ctx.primitives.int64,
                ctx.primitives.uint64,
                ctx.primitives.float,
            ]
            .iter()
            .any(|ty| ctx.unifier.unioned(a_ty, *ty)));
            a
        }
        BasicValueEnum::PointerValue(n)
            if a_ty.obj_id(&ctx.unifier).is_some_and(|id| id == PrimDef::NDArray.id()) =>
        {
            let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, a_ty);
            let llvm_ndarray_ty = ctx.get_llvm_type(generator, elem_ty);
            let n = NDArrayValue::from_ptr_val(n, llvm_usize, None);
            let n_sz = irrt::call_ndarray_calc_size(generator, ctx, &n.dim_sizes(), (None, None));
            if ctx.registry.llvm_options.opt_level == OptimizationLevel::None {
                let n_sz_eqz = ctx
                    .builder
                    .build_int_compare(IntPredicate::NE, n_sz, n_sz.get_type().const_zero(), "")
                    .unwrap();
                ctx.make_assert(
                    generator,
                    n_sz_eqz,
                    "0:ValueError",
                    "zero-size array to reduction operation minimum which has no identity",
                    [None, None, None],
                    ctx.current_loc,
                );
            }
            let accumulator_addr = generator.gen_var_alloc(ctx, llvm_ndarray_ty, None)?;
            unsafe {
                let identity =
                    n.data().get_unchecked(ctx, generator, &llvm_usize.const_zero(), None);
                ctx.builder.build_store(accumulator_addr, identity).unwrap();
            }
            gen_for_callback_incrementing(
                generator,
                ctx,
                llvm_usize.const_int(1, false),
                (n_sz, false),
                |generator, ctx, _, idx| {
                    let elem = unsafe { n.data().get_unchecked(ctx, generator, &idx, None) };
                    let accumulator = ctx.builder.build_load(accumulator_addr, "").unwrap();
                    let result = call_min(ctx, (elem_ty, accumulator), (elem_ty, elem));
                    ctx.builder.build_store(accumulator_addr, result).unwrap();
                    Ok(())
                },
                llvm_usize.const_int(1, false),
            )?;
            let accumulator = ctx.builder.build_load(accumulator_addr, "").unwrap();
            accumulator
        }
        _ => unsupported_type(ctx, FN_NAME, &[a_ty]),
    })
 }
 /// Invokes the `np_minimum` builtin function.
 pub fn call_numpy_minimum<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
@ -803,7 +786,7 @@ pub fn call_numpy_minimum<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -877,18 +860,20 @@ pub fn call_max<'ctx>(
    }
 }
-/// Invokes the `np_max` builtin function.
+/// Invokes the `np_max`, `np_min`, `np_argmax`, `np_argmin` functions
-pub fn call_numpy_max<'ctx, G: CodeGenerator + ?Sized>(
+/// * `fn_name`: Can be one of `"np_argmin"`, `"np_argmax"`, `"np_max"`, `"np_min"`
 pub fn call_numpy_max_min<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    a: (Type, BasicValueEnum<'ctx>),
    fn_name: &str,
 ) -> Result<BasicValueEnum<'ctx>, String> {
-    const FN_NAME: &str = "np_max";
+    debug_assert!(["np_argmin", "np_argmax", "np_max", "np_min"].iter().any(|f| *f == fn_name));
    let llvm_int64 = ctx.ctx.i64_type();
    let llvm_usize = generator.get_size_type(ctx.ctx);
    let (a_ty, a) = a;
    Ok(match a {
        BasicValueEnum::IntValue(_) | BasicValueEnum::FloatValue(_) => {
            debug_assert!([
@ -902,9 +887,12 @@ pub fn call_numpy_max<'ctx, G: CodeGenerator + ?Sized>(
            .iter()
            .any(|ty| ctx.unifier.unioned(a_ty, *ty)));
-            a
+            match fn_name {
                "np_argmin" | "np_argmax" => llvm_int64.const_zero().into(),
                "np_max" | "np_min" => a,
                _ => codegen_unreachable!(ctx),
            }
        }
        BasicValueEnum::PointerValue(n)
            if a_ty.obj_id(&ctx.unifier).is_some_and(|id| id == PrimDef::NDArray.id()) =>
        {
@ -923,41 +911,82 @@ pub fn call_numpy_max<'ctx, G: CodeGenerator + ?Sized>(
                    generator,
                    n_sz_eqz,
                    "0:ValueError",
-                    "zero-size array to reduction operation minimum which has no identity",
+                    format!("zero-size array to reduction operation {fn_name}").as_str(),
                    [None, None, None],
                    ctx.current_loc,
                );
            }
            let accumulator_addr = generator.gen_var_alloc(ctx, llvm_ndarray_ty, None)?;
            let res_idx = generator.gen_var_alloc(ctx, llvm_int64.into(), None)?;
            unsafe {
                let identity =
                    n.data().get_unchecked(ctx, generator, &llvm_usize.const_zero(), None);
                ctx.builder.build_store(accumulator_addr, identity).unwrap();
                ctx.builder.build_store(res_idx, llvm_int64.const_zero()).unwrap();
            }
            gen_for_callback_incrementing(
                generator,
                ctx,
-                llvm_usize.const_int(1, false),
+                None,
                llvm_int64.const_int(1, false),
                (n_sz, false),
                |generator, ctx, _, idx| {
                    let elem = unsafe { n.data().get_unchecked(ctx, generator, &idx, None) };
                    let accumulator = ctx.builder.build_load(accumulator_addr, "").unwrap();
-                    let result = call_max(ctx, (elem_ty, accumulator), (elem_ty, elem));
+                    let cur_idx = ctx.builder.build_load(res_idx, "").unwrap();
                    let result = match fn_name {
                        "np_argmin" | "np_min" => {
                            call_min(ctx, (elem_ty, accumulator), (elem_ty, elem))
                        }
                        "np_argmax" | "np_max" => {
                            call_max(ctx, (elem_ty, accumulator), (elem_ty, elem))
                        }
                        _ => codegen_unreachable!(ctx),
                    };
                    let updated_idx = match (accumulator, result) {
                        (BasicValueEnum::IntValue(m), BasicValueEnum::IntValue(n)) => ctx
                            .builder
                            .build_select(
                                ctx.builder.build_int_compare(IntPredicate::NE, m, n, "").unwrap(),
                                idx.into(),
                                cur_idx,
                                "",
                            )
                            .unwrap(),
                        (BasicValueEnum::FloatValue(m), BasicValueEnum::FloatValue(n)) => ctx
                            .builder
                            .build_select(
                                ctx.builder
                                    .build_float_compare(FloatPredicate::ONE, m, n, "")
                                    .unwrap(),
                                idx.into(),
                                cur_idx,
                                "",
                            )
                            .unwrap(),
                        _ => unsupported_type(ctx, fn_name, &[elem_ty, elem_ty]),
                    };
                    ctx.builder.build_store(res_idx, updated_idx).unwrap();
                    ctx.builder.build_store(accumulator_addr, result).unwrap();
                    Ok(())
                },
-                llvm_usize.const_int(1, false),
+                llvm_int64.const_int(1, false),
            )?;
-            let accumulator = ctx.builder.build_load(accumulator_addr, "").unwrap();
+            match fn_name {
-            accumulator
+                "np_argmin" | "np_argmax" => ctx.builder.build_load(res_idx, "").unwrap(),
                "np_max" | "np_min" => ctx.builder.build_load(accumulator_addr, "").unwrap(),
                _ => codegen_unreachable!(ctx),
            }
        }
-        _ => unsupported_type(ctx, FN_NAME, &[a_ty]),
+        _ => unsupported_type(ctx, fn_name, &[a_ty]),
    })
 }
@ -1019,7 +1048,7 @@ pub fn call_numpy_maximum<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1383,7 +1412,7 @@ create_helper_call_numpy_unary_elementwise_float_to_float!(
 create_helper_call_numpy_unary_elementwise_float_to_float!(
    call_numpy_rint,
    "np_rint",
-    llvm_intrinsics::call_float_roundeven
+    llvm_intrinsics::call_float_rint
 );
 create_helper_call_numpy_unary_elementwise_float_to_float!(
@ -1459,7 +1488,7 @@ pub fn call_numpy_arctan2<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1526,7 +1555,7 @@ pub fn call_numpy_copysign<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1593,7 +1622,7 @@ pub fn call_numpy_fmax<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1660,7 +1689,7 @@ pub fn call_numpy_fmin<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1783,7 +1812,7 @@ pub fn call_numpy_hypot<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1850,7 +1879,7 @@ pub fn call_numpy_nextafter<'ctx, G: CodeGenerator + ?Sized>(
            } else if is_ndarray2 {
                unpack_ndarray_var_tys(&mut ctx.unifier, x2_ty).0
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            let x1_scalar_ty = if is_ndarray1 { dtype } else { x1_ty };
@ -1874,3 +1903,501 @@ pub fn call_numpy_nextafter<'ctx, G: CodeGenerator + ?Sized>(
        _ => unsupported_type(ctx, FN_NAME, &[x1_ty, x2_ty]),
    })
 }
 /// Allocates a struct with the fields specified by `out_matrices` and returns a pointer to it
 fn build_output_struct<'ctx>(
    ctx: &mut CodeGenContext<'ctx, '_>,
    out_matrices: Vec<BasicValueEnum<'ctx>>,
 ) -> PointerValue<'ctx> {
    let field_ty =
        out_matrices.iter().map(BasicValueEnum::get_type).collect::<Vec<BasicTypeEnum>>();
    let out_ty = ctx.ctx.struct_type(&field_ty, false);
    let out_ptr = ctx.builder.build_alloca(out_ty, "").unwrap();
    for (i, v) in out_matrices.into_iter().enumerate() {
        unsafe {
            let ptr = ctx
                .builder
                .build_in_bounds_gep(
                    out_ptr,
                    &[
                        ctx.ctx.i32_type().const_zero(),
                        ctx.ctx.i32_type().const_int(i as u64, false),
                    ],
                    "",
                )
                .unwrap();
            ctx.builder.build_store(ptr, v).unwrap();
        }
    }
    out_ptr
 }
 /// Invokes the `np_linalg_cholesky` linalg function
 pub fn call_np_linalg_cholesky<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_cholesky";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let out = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_cholesky(ctx, x1, out, None);
        Ok(out)
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `np_linalg_qr` linalg function
 pub fn call_np_linalg_qr<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_qr";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unimplemented!("{FN_NAME} operates on float type NdArrays only");
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let k = llvm_intrinsics::call_int_smin(ctx, dim0, dim1, None);
        let out_q = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, k])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_r = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[k, dim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_qr(ctx, x1, out_q, out_r, None);
        let out_ptr = build_output_struct(ctx, vec![out_q, out_r]);
        Ok(ctx.builder.build_load(out_ptr, "QR_Factorization_result").map(Into::into).unwrap())
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `np_linalg_svd` linalg function
 pub fn call_np_linalg_svd<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_svd";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let k = llvm_intrinsics::call_int_smin(ctx, dim0, dim1, None);
        let out_u = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_s = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[k])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_vh = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim1, dim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_svd(ctx, x1, out_u, out_s, out_vh, None);
        let out_ptr = build_output_struct(ctx, vec![out_u, out_s, out_vh]);
        Ok(ctx.builder.build_load(out_ptr, "SVD_Factorization_result").map(Into::into).unwrap())
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `np_linalg_inv` linalg function
 pub fn call_np_linalg_inv<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_inv";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let out = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_inv(ctx, x1, out, None);
        Ok(out)
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `np_linalg_pinv` linalg function
 pub fn call_np_linalg_pinv<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_pinv";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let out = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim1, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_pinv(ctx, x1, out, None);
        Ok(out)
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `sp_linalg_lu` linalg function
 pub fn call_sp_linalg_lu<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "sp_linalg_lu";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let dim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let k = llvm_intrinsics::call_int_smin(ctx, dim0, dim1, None);
        let out_l = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, k])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_u = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[k, dim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_sp_linalg_lu(ctx, x1, out_l, out_u, None);
        let out_ptr = build_output_struct(ctx, vec![out_l, out_u]);
        Ok(ctx.builder.build_load(out_ptr, "LU_Factorization_result").map(Into::into).unwrap())
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `np_linalg_matrix_power` linalg function
 pub fn call_np_linalg_matrix_power<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
    x2: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_matrix_power";
    let (x1_ty, x1) = x1;
    let (x2_ty, x2) = x2;
    let x2 = call_float(generator, ctx, (x2_ty, x2)).unwrap();
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let (BasicValueEnum::PointerValue(n1), BasicValueEnum::FloatValue(n2)) = (x1, x2) {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty, x2_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        // Changing second parameter to a `NDArray` for uniformity in function call
        let n2_array = numpy::create_ndarray_const_shape(
            generator,
            ctx,
            elem_ty,
            &[llvm_usize.const_int(1, false)],
        )
        .unwrap();
        unsafe {
            n2_array.data().set_unchecked(
                ctx,
                generator,
                &llvm_usize.const_zero(),
                n2.as_basic_value_enum(),
            );
        };
        let n2_array = n2_array.as_base_value().as_basic_value_enum();
        let outdim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let outdim1 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_int(1, false), None)
                .into_int_value()
        };
        let out = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[outdim0, outdim1])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_np_linalg_matrix_power(ctx, x1, n2_array, out, None);
        Ok(out)
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty, x2_ty])
    }
 }
 /// Invokes the `np_linalg_det` linalg function
 pub fn call_np_linalg_det<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "np_linalg_matrix_power";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(_) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        // Changing second parameter to a `NDArray` for uniformity in function call
        let out = numpy::create_ndarray_const_shape(
            generator,
            ctx,
            elem_ty,
            &[llvm_usize.const_int(1, false)],
        )
        .unwrap();
        extern_fns::call_np_linalg_det(ctx, x1, out.as_base_value().as_basic_value_enum(), None);
        let res =
            unsafe { out.data().get_unchecked(ctx, generator, &llvm_usize.const_zero(), None) };
        Ok(res)
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `sp_linalg_schur` linalg function
 pub fn call_sp_linalg_schur<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "sp_linalg_schur";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let out_t = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_z = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_sp_linalg_schur(ctx, x1, out_t, out_z, None);
        let out_ptr = build_output_struct(ctx, vec![out_t, out_z]);
        Ok(ctx.builder.build_load(out_ptr, "Schur_Factorization_result").map(Into::into).unwrap())
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
 /// Invokes the `sp_linalg_hessenberg` linalg function
 pub fn call_sp_linalg_hessenberg<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "sp_linalg_hessenberg";
    let (x1_ty, x1) = x1;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    if let BasicValueEnum::PointerValue(n1) = x1 {
        let (elem_ty, _) = unpack_ndarray_var_tys(&mut ctx.unifier, x1_ty);
        let n1_elem_ty = ctx.get_llvm_type(generator, elem_ty);
        let BasicTypeEnum::FloatType(_) = n1_elem_ty else {
            unsupported_type(ctx, FN_NAME, &[x1_ty]);
        };
        let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let dim0 = unsafe {
            n1.dim_sizes()
                .get_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
                .into_int_value()
        };
        let out_h = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        let out_q = numpy::create_ndarray_const_shape(generator, ctx, elem_ty, &[dim0, dim0])
            .unwrap()
            .as_base_value()
            .as_basic_value_enum();
        extern_fns::call_sp_linalg_hessenberg(ctx, x1, out_h, out_q, None);
        let out_ptr = build_output_struct(ctx, vec![out_h, out_q]);
        Ok(ctx
            .builder
            .build_load(out_ptr, "Hessenberg_decomposition_result")
            .map(Into::into)
            .unwrap())
    } else {
        unsupported_type(ctx, FN_NAME, &[x1_ty])
    }
 }
--- a/nac3core/src/codegen/classes.rs
+++ b/nac3core/src/codegen/classes.rs
@ -713,12 +713,25 @@ impl<'ctx> ListValue<'ctx> {
    /// If `size` is [None], the size stored in the field of this instance is used instead.
    pub fn create_data(
        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
+        ctx: &mut CodeGenContext<'ctx, '_>,
        elem_ty: BasicTypeEnum<'ctx>,
        size: Option<IntValue<'ctx>>,
    ) {
        let size = size.unwrap_or_else(|| self.load_size(ctx, None));
-        self.store_data(ctx, ctx.builder.build_array_alloca(elem_ty, size, "").unwrap());
+
        let data = ctx
            .builder
            .build_select(
                ctx.builder
                    .build_int_compare(IntPredicate::NE, size, self.llvm_usize.const_zero(), "")
                    .unwrap(),
                ctx.builder.build_array_alloca(elem_ty, size, "").unwrap(),
                elem_ty.ptr_type(AddressSpace::default()).const_zero(),
                "",
            )
            .map(BasicValueEnum::into_pointer_value)
            .unwrap();
        self.store_data(ctx, data);
    }
    /// Returns the double-indirection pointer to the `data` array, as if by calling `getelementptr`
@ -1237,11 +1250,13 @@ impl<'ctx> NDArrayType<'ctx> {
    /// Returns the element type of this `ndarray` type.
    #[must_use]
-    pub fn element_type(&self) -> BasicTypeEnum<'ctx> {
+    pub fn element_type(&self) -> AnyTypeEnum<'ctx> {
        self.as_base_type()
            .get_element_type()
            .into_struct_type()
            .get_field_type_at_index(2)
            .map(BasicTypeEnum::into_pointer_type)
            .map(PointerType::get_element_type)
            .unwrap()
    }
 }
@ -1391,7 +1406,7 @@ impl<'ctx> NDArrayValue<'ctx> {
    /// Returns the double-indirection pointer to the `data` array, as if by calling `getelementptr`
    /// on the field.
-    fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
+    pub fn ptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
        let llvm_i32 = ctx.ctx.i32_type();
        let var_name = self.name.map(|v| format!("{v}.data.addr")).unwrap_or_default();
@ -1704,6 +1719,7 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> ArrayLikeIndexer<'ctx, Index>
        gen_for_callback_incrementing(
            generator,
            ctx,
            None,
            llvm_usize.const_zero(),
            (len, false),
            |generator, ctx, _, i| {
--- a/nac3core/src/codegen/concrete_type.rs
+++ b/nac3core/src/codegen/concrete_type.rs
@ -25,6 +25,7 @@ pub struct ConcreteFuncArg {
    pub name: StrRef,
    pub ty: ConcreteType,
    pub default_value: Option<SymbolValue>,
    pub is_vararg: bool,
 }
 #[derive(Clone, Debug)]
@ -46,9 +47,7 @@ pub enum ConcreteTypeEnum {
    TPrimitive(Primitive),
    TTuple {
        ty: Vec<ConcreteType>,
-    },
+        is_vararg_ctx: bool,
    TList {
        ty: ConcreteType,
    },
    TObj {
        obj_id: DefinitionId,
@ -105,8 +104,16 @@ impl ConcreteTypeStore {
                .iter()
                .map(|arg| ConcreteFuncArg {
                    name: arg.name,
-                    ty: self.from_unifier_type(unifier, primitives, arg.ty, cache),
+                    ty: if arg.is_vararg {
                        let tuple_ty = unifier
                            .add_ty(TypeEnum::TTuple { ty: vec![arg.ty], is_vararg_ctx: true });
                        self.from_unifier_type(unifier, primitives, tuple_ty, cache)
                    } else {
                        self.from_unifier_type(unifier, primitives, arg.ty, cache)
                    },
                    default_value: arg.default_value.clone(),
                    is_vararg: arg.is_vararg,
                })
                .collect(),
            ret: self.from_unifier_type(unifier, primitives, signature.ret, cache),
@ -161,14 +168,12 @@ impl ConcreteTypeStore {
            cache.insert(ty, None);
            let ty_enum = unifier.get_ty(ty);
            let result = match &*ty_enum {
-                TypeEnum::TTuple { ty } => ConcreteTypeEnum::TTuple {
+                TypeEnum::TTuple { ty, is_vararg_ctx } => ConcreteTypeEnum::TTuple {
                    ty: ty
                        .iter()
                        .map(|t| self.from_unifier_type(unifier, primitives, *t, cache))
                        .collect(),
-                },
+                    is_vararg_ctx: *is_vararg_ctx,
                TypeEnum::TList { ty } => ConcreteTypeEnum::TList {
                    ty: self.from_unifier_type(unifier, primitives, *ty, cache),
                },
                TypeEnum::TObj { obj_id, fields, params } => ConcreteTypeEnum::TObj {
                    obj_id: *obj_id,
@ -254,15 +259,13 @@ impl ConcreteTypeStore {
                *cache.get_mut(&cty).unwrap() = Some(ty);
                return ty;
            }
-            ConcreteTypeEnum::TTuple { ty } => TypeEnum::TTuple {
+            ConcreteTypeEnum::TTuple { ty, is_vararg_ctx } => TypeEnum::TTuple {
                ty: ty
                    .iter()
                    .map(|cty| self.to_unifier_type(unifier, primitives, *cty, cache))
                    .collect(),
                is_vararg_ctx: *is_vararg_ctx,
            },
            ConcreteTypeEnum::TList { ty } => {
                TypeEnum::TList { ty: self.to_unifier_type(unifier, primitives, *ty, cache) }
            }
            ConcreteTypeEnum::TVirtual { ty } => {
                TypeEnum::TVirtual { ty: self.to_unifier_type(unifier, primitives, *ty, cache) }
            }
@ -286,6 +289,7 @@ impl ConcreteTypeStore {
                        name: arg.name,
                        ty: self.to_unifier_type(unifier, primitives, arg.ty, cache),
                        default_value: arg.default_value.clone(),
                        is_vararg: false,
                    })
                    .collect(),
                ret: self.to_unifier_type(unifier, primitives, *ret, cache),
--- a/nac3core/src/codegen/expr.rs
+++ b/nac3core/src/codegen/expr.rs
--- a/nac3core/src/codegen/extern_fns.rs
+++ b/nac3core/src/codegen/extern_fns.rs
@ -4,514 +4,97 @@ use itertools::Either;
 use crate::codegen::CodeGenContext;
-/// Invokes the [`tan`](https://en.cppreference.com/w/c/numeric/math/tan) function.
+/// Macro to generate extern function
-pub fn call_tan<'ctx>(
+/// Both function return type and function parameter type are `FloatValue`
-    ctx: &CodeGenContext<'ctx, '_>,
+///
-    arg: FloatValue<'ctx>,
+/// Arguments:
 /// * `unary/binary`: Whether the extern function requires one (unary) or two (binary) operands
 /// * `$fn_name:ident`: The identifier of the rust function to be generated
 /// * `$extern_fn:literal`: Name of underlying extern function
 ///
 /// Optional Arguments:
 /// * `$(,$attributes:literal)*)`: Attributes linked with the extern function.
 ///   The default attributes are "mustprogress", "nofree", "nounwind", "willreturn", and "writeonly".
 ///   These will be used unless other attributes are specified
 /// * `$(,$args:ident)*`: Operands of the extern function
 ///   The data type of these operands will be set to `FloatValue`
 ///  
 macro_rules! generate_extern_fn {
    ("unary", $fn_name:ident, $extern_fn:literal) => {
        generate_extern_fn!($fn_name, $extern_fn, arg, "mustprogress", "nofree", "nounwind", "willreturn", "writeonly");
    };
    ("unary", $fn_name:ident, $extern_fn:literal $(,$attributes:literal)*) => {
        generate_extern_fn!($fn_name, $extern_fn, arg $(,$attributes)*);
    };
    ("binary", $fn_name:ident, $extern_fn:literal) => {
        generate_extern_fn!($fn_name, $extern_fn, arg1, arg2, "mustprogress", "nofree", "nounwind", "willreturn", "writeonly");
    };
    ("binary", $fn_name:ident, $extern_fn:literal $(,$attributes:literal)*) => {
        generate_extern_fn!($fn_name, $extern_fn, arg1, arg2 $(,$attributes)*);
    };
    ($fn_name:ident, $extern_fn:literal $(,$args:ident)* $(,$attributes:literal)*) => {
        #[doc = concat!("Invokes the [`", stringify!($extern_fn), "`](https://en.cppreference.com/w/c/numeric/math/", stringify!($llvm_name), ") function." )]
        pub fn $fn_name<'ctx>(
            ctx: &CodeGenContext<'ctx, '_>
            $(,$args: FloatValue<'ctx>)*,
            name: Option<&str>,
        ) -> FloatValue<'ctx> {
-    const FN_NAME: &str = "tan";
+            const FN_NAME: &str = $extern_fn;
            let llvm_f64 = ctx.ctx.f64_type();
-    debug_assert_eq!(arg.get_type(), llvm_f64);
+            $(debug_assert_eq!($args.get_type(), llvm_f64);)*
            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
-        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+                let fn_type = llvm_f64.fn_type(&[$($args.get_type().into()),*], false);
                let func = ctx.module.add_function(FN_NAME, fn_type, None);
-        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+                for attr in [$($attributes),*] {
                    func.add_attribute(
                        AttributeLoc::Function,
                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
                    );
                }
                func
            });
            ctx.builder
-        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
+                .build_call(extern_fn, &[$($args.into()),*], name.unwrap_or_default())
                .map(CallSiteValue::try_as_basic_value)
                .map(|v| v.map_left(BasicValueEnum::into_float_value))
                .map(Either::unwrap_left)
                .unwrap()
        }
    };
 }
-/// Invokes the [`asin`](https://en.cppreference.com/w/c/numeric/math/asin) function.
+generate_extern_fn!("unary", call_tan, "tan");
-pub fn call_asin<'ctx>(
+generate_extern_fn!("unary", call_asin, "asin");
-    ctx: &CodeGenContext<'ctx, '_>,
+generate_extern_fn!("unary", call_acos, "acos");
-    arg: FloatValue<'ctx>,
+generate_extern_fn!("unary", call_atan, "atan");
-    name: Option<&str>,
+generate_extern_fn!("unary", call_sinh, "sinh");
-) -> FloatValue<'ctx> {
+generate_extern_fn!("unary", call_cosh, "cosh");
-    const FN_NAME: &str = "asin";
+generate_extern_fn!("unary", call_tanh, "tanh");
-
+generate_extern_fn!("unary", call_asinh, "asinh");
-    let llvm_f64 = ctx.ctx.f64_type();
+generate_extern_fn!("unary", call_acosh, "acosh");
-    debug_assert_eq!(arg.get_type(), llvm_f64);
+generate_extern_fn!("unary", call_atanh, "atanh");
-
+generate_extern_fn!("unary", call_expm1, "expm1");
-    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+generate_extern_fn!(
-        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+    "unary",
-        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+    call_cbrt,
-        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+    "cbrt",
-            func.add_attribute(
+    "mustprogress",
-                AttributeLoc::Function,
+    "nofree",
-                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+    "nosync",
    "nounwind",
    "readonly",
    "willreturn"
 );
-        }
+generate_extern_fn!("unary", call_erf, "erf", "nounwind");
 generate_extern_fn!("unary", call_erfc, "erfc", "nounwind");
 generate_extern_fn!("unary", call_j1, "j1", "nounwind");
-        func
+generate_extern_fn!("binary", call_atan2, "atan2");
-    });
+generate_extern_fn!("binary", call_hypot, "hypot", "nounwind");
-
+generate_extern_fn!("binary", call_nextafter, "nextafter", "nounwind");
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`acos`](https://en.cppreference.com/w/c/numeric/math/acos) function.
 pub fn call_acos<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "acos";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`atan`](https://en.cppreference.com/w/c/numeric/math/atan) function.
 pub fn call_atan<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "atan";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`sinh`](https://en.cppreference.com/w/c/numeric/math/sinh) function.
 pub fn call_sinh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "sinh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`cosh`](https://en.cppreference.com/w/c/numeric/math/cosh) function.
 pub fn call_cosh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "cosh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`tanh`](https://en.cppreference.com/w/c/numeric/math/tanh) function.
 pub fn call_tanh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "tanh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`asinh`](https://en.cppreference.com/w/c/numeric/math/asinh) function.
 pub fn call_asinh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "asinh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`acosh`](https://en.cppreference.com/w/c/numeric/math/acosh) function.
 pub fn call_acosh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "acosh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`atanh`](https://en.cppreference.com/w/c/numeric/math/atanh) function.
 pub fn call_atanh<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "atanh";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`expm1`](https://en.cppreference.com/w/c/numeric/math/expm1) function.
 pub fn call_expm1<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "expm1";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`cbrt`](https://en.cppreference.com/w/c/numeric/math/cbrt) function.
 pub fn call_cbrt<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "cbrt";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nosync", "nounwind", "readonly", "willreturn"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`erf`](https://en.cppreference.com/w/c/numeric/math/erf) function.
 pub fn call_erf<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "erf";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        func.add_attribute(
            AttributeLoc::Function,
            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
        );
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`erfc`](https://en.cppreference.com/w/c/numeric/math/erfc) function.
 pub fn call_erfc<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "erfc";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        func.add_attribute(
            AttributeLoc::Function,
            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
        );
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`j1`](https://www.gnu.org/software/libc/manual/html_node/Special-Functions.html#index-j1)
 /// function.
 pub fn call_j1<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    arg: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "j1";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(arg.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        func.add_attribute(
            AttributeLoc::Function,
            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
        );
        func
    });
    ctx.builder
        .build_call(extern_fn, &[arg.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`atan2`](https://en.cppreference.com/w/c/numeric/math/atan2) function.
 pub fn call_atan2<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    y: FloatValue<'ctx>,
    x: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "atan2";
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(y.get_type(), llvm_f64);
    debug_assert_eq!(x.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
            func.add_attribute(
                AttributeLoc::Function,
                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
            );
        }
        func
    });
    ctx.builder
        .build_call(extern_fn, &[y.into(), x.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`ldexp`](https://en.cppreference.com/w/c/numeric/math/ldexp) function.
 pub fn call_ldexp<'ctx>(
@ -548,66 +131,61 @@ pub fn call_ldexp<'ctx>(
        .unwrap()
 }
-/// Invokes the [`hypot`](https://en.cppreference.com/w/c/numeric/math/hypot) function.
+/// Macro to generate `np_linalg` and `sp_linalg` functions
-pub fn call_hypot<'ctx>(
+/// The function takes as input `NDArray` and returns ()
-    ctx: &CodeGenContext<'ctx, '_>,
+///
-    x: FloatValue<'ctx>,
+/// Arguments:
-    y: FloatValue<'ctx>,
+/// * `$fn_name:ident`: The identifier of the rust function to be generated
 /// * `$extern_fn:literal`: Name of underlying extern function
 /// * (2/3/4): Number of `NDArray` that function takes as input
 ///
 /// Note:
 /// The operands and resulting `NDArray` are both passed as input to the funcion
 /// It is the responsibility of caller to ensure that output `NDArray` is properly allocated on stack
 /// The function changes the content of the output `NDArray` in-place
 macro_rules! generate_linalg_extern_fn {
    ($fn_name:ident, $extern_fn:literal, 2) => {
        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2);
    };
    ($fn_name:ident, $extern_fn:literal, 3) => {
        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2, mat3);
    };
    ($fn_name:ident, $extern_fn:literal, 4) => {
        generate_linalg_extern_fn!($fn_name, $extern_fn, mat1, mat2, mat3, mat4);
    };
    ($fn_name:ident, $extern_fn:literal $(,$input_matrix:ident)*) => {
        #[doc = concat!("Invokes the linalg `", stringify!($extern_fn), " function." )]
        pub fn $fn_name<'ctx>(
            ctx: &mut CodeGenContext<'ctx, '_>
            $(,$input_matrix: BasicValueEnum<'ctx>)*,
            name: Option<&str>,
-) -> FloatValue<'ctx> {
+        ){
-    const FN_NAME: &str = "hypot";
+            const FN_NAME: &str = $extern_fn;
    let llvm_f64 = ctx.ctx.f64_type();
    debug_assert_eq!(x.get_type(), llvm_f64);
    debug_assert_eq!(y.get_type(), llvm_f64);
            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
-        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
+                let fn_type = ctx.ctx.void_type().fn_type(&[$($input_matrix.get_type().into()),*], false);
                let func = ctx.module.add_function(FN_NAME, fn_type, None);
                for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
                    func.add_attribute(
                        AttributeLoc::Function,
-            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
+                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
                    );
-
+                }
                func
            });
-    ctx.builder
+            ctx.builder.build_call(extern_fn, &[$($input_matrix.into(),)*], name.unwrap_or_default()).unwrap();
-        .build_call(extern_fn, &[x.into(), y.into()], name.unwrap_or_default())
+        }
-        .map(CallSiteValue::try_as_basic_value)
+    };
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
-/// Invokes the [`nextafter`](https://en.cppreference.com/w/c/numeric/math/nextafter) function.
+generate_linalg_extern_fn!(call_np_linalg_cholesky, "np_linalg_cholesky", 2);
-pub fn call_nextafter<'ctx>(
+generate_linalg_extern_fn!(call_np_linalg_qr, "np_linalg_qr", 3);
-    ctx: &CodeGenContext<'ctx, '_>,
+generate_linalg_extern_fn!(call_np_linalg_svd, "np_linalg_svd", 4);
-    from: FloatValue<'ctx>,
+generate_linalg_extern_fn!(call_np_linalg_inv, "np_linalg_inv", 2);
-    to: FloatValue<'ctx>,
+generate_linalg_extern_fn!(call_np_linalg_pinv, "np_linalg_pinv", 2);
-    name: Option<&str>,
+generate_linalg_extern_fn!(call_np_linalg_matrix_power, "np_linalg_matrix_power", 3);
-) -> FloatValue<'ctx> {
+generate_linalg_extern_fn!(call_np_linalg_det, "np_linalg_det", 2);
-    const FN_NAME: &str = "nextafter";
+generate_linalg_extern_fn!(call_sp_linalg_lu, "sp_linalg_lu", 3);
-
+generate_linalg_extern_fn!(call_sp_linalg_schur, "sp_linalg_schur", 3);
-    let llvm_f64 = ctx.ctx.f64_type();
+generate_linalg_extern_fn!(call_sp_linalg_hessenberg, "sp_linalg_hessenberg", 3);
    debug_assert_eq!(from.get_type(), llvm_f64);
    debug_assert_eq!(to.get_type(), llvm_f64);
    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_f64.into()], false);
        let func = ctx.module.add_function(FN_NAME, fn_type, None);
        func.add_attribute(
            AttributeLoc::Function,
            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
        );
        func
    });
    ctx.builder
        .build_call(extern_fn, &[from.into(), to.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
--- a/nac3core/src/codegen/generator.rs
+++ b/nac3core/src/codegen/generator.rs
@ -57,6 +57,7 @@ pub trait CodeGenerator {
    /// - fun: Function signature, definition ID and the substitution key.
    /// - params: Function parameters. Note that this does not include the object even if the
    ///   function is a class method.
    ///
    /// Note that this function should check if the function is generated in another thread (due to
    /// possible race condition), see the default implementation for an example.
    fn gen_func_instance<'ctx>(
@ -123,11 +124,45 @@ pub trait CodeGenerator {
        ctx: &mut CodeGenContext<'ctx, '_>,
        target: &Expr<Option<Type>>,
        value: ValueEnum<'ctx>,
        value_ty: Type,
    ) -> Result<(), String>
    where
        Self: Sized,
    {
-        gen_assign(self, ctx, target, value)
+        gen_assign(self, ctx, target, value, value_ty)
    }
    /// Generate code for an assignment expression where LHS is a `"target_list"`.
    ///
    /// See <https://docs.python.org/3/reference/simple_stmts.html#assignment-statements>.
    fn gen_assign_target_list<'ctx>(
        &mut self,
        ctx: &mut CodeGenContext<'ctx, '_>,
        targets: &Vec<Expr<Option<Type>>>,
        value: ValueEnum<'ctx>,
        value_ty: Type,
    ) -> Result<(), String>
    where
        Self: Sized,
    {
        gen_assign_target_list(self, ctx, targets, value, value_ty)
    }
    /// Generate code for an item assignment.
    ///
    /// i.e., `target[key] = value`
    fn gen_setitem<'ctx>(
        &mut self,
        ctx: &mut CodeGenContext<'ctx, '_>,
        target: &Expr<Option<Type>>,
        key: &Expr<Option<Type>>,
        value: ValueEnum<'ctx>,
        value_ty: Type,
    ) -> Result<(), String>
    where
        Self: Sized,
    {
        gen_setitem(self, ctx, target, key, value, value_ty)
    }
    /// Generate code for a while expression.
--- a/nac3core/src/codegen/irrt/irrt.c
+++ b/nac3core/src/codegen/irrt/irrt.c
@ -1,389 +0,0 @@
 typedef _BitInt(8) int8_t;
 typedef unsigned _BitInt(8) uint8_t;
 typedef _BitInt(32) int32_t;
 typedef unsigned _BitInt(32) uint32_t;
 typedef _BitInt(64) int64_t;
 typedef unsigned _BitInt(64) uint64_t;
 # define MAX(a, b) (a > b ? a : b)
 # define MIN(a, b) (a > b ? b : a)
 # define NULL ((void *) 0)
 // adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
 // need to make sure `exp >= 0` before calling this function
 #define DEF_INT_EXP(T) T __nac3_int_exp_##T( \
    T base, \
    T exp \
 ) { \
    T res = (T)1; \
    /* repeated squaring method */ \
    do { \
       if (exp & 1) res *= base;  /* for n odd */ \
       exp >>= 1; \
       base *= base; \
    } while (exp); \
    return res; \
 } \
 DEF_INT_EXP(int32_t)
 DEF_INT_EXP(int64_t)
 DEF_INT_EXP(uint32_t)
 DEF_INT_EXP(uint64_t)
 int32_t __nac3_slice_index_bound(int32_t i, const int32_t len) {
    if (i < 0) {
        i = len + i;
    }
    if (i < 0) {
        return 0;
    } else if (i > len) {
        return len;
    }
    return i;
 }
 int32_t __nac3_range_slice_len(const int32_t start, const int32_t end, const int32_t step) {
    int32_t diff = end - start;
    if (diff > 0 && step > 0) {
        return ((diff - 1) / step) + 1;
    } else if (diff < 0 && step < 0) {
        return ((diff + 1) / step) + 1;
    } else {
        return 0;
    }
 }
 // Handle list assignment and dropping part of the list when
 // both dest_step and src_step are +1.
 // - All the index must *not* be out-of-bound or negative,
 // - The end index is *inclusive*,
 // - The length of src and dest slice size should already
 // be checked: if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest)
 int32_t __nac3_list_slice_assign_var_size(
    int32_t dest_start,
    int32_t dest_end,
    int32_t dest_step,
    uint8_t *dest_arr,
    int32_t dest_arr_len,
    int32_t src_start,
    int32_t src_end,
    int32_t src_step,
    uint8_t *src_arr,
    int32_t src_arr_len,
    const int32_t size
 ) {
    /* if dest_arr_len == 0, do nothing since we do not support extending list */
    if (dest_arr_len == 0) return dest_arr_len;
    /* if both step is 1, memmove directly, handle the dropping of the list, and shrink size */
    if (src_step == dest_step && dest_step == 1) {
        const int32_t src_len = (src_end >= src_start) ? (src_end - src_start + 1) : 0;
        const int32_t dest_len = (dest_end >= dest_start) ? (dest_end - dest_start + 1) : 0;
        if (src_len > 0) {
            __builtin_memmove(
                dest_arr + dest_start * size,
                src_arr + src_start * size,
                src_len * size
            );
        }
        if (dest_len > 0) {
            /* dropping */
            __builtin_memmove(
                dest_arr + (dest_start + src_len) * size,
                dest_arr + (dest_end + 1) * size,
                (dest_arr_len - dest_end - 1) * size
            );
        }
        /* shrink size */
        return dest_arr_len - (dest_len - src_len);
    }
    /* if two range overlaps, need alloca */
    uint8_t need_alloca =
        (dest_arr == src_arr)
        && !(
            MAX(dest_start, dest_end) < MIN(src_start, src_end)
            || MAX(src_start, src_end) < MIN(dest_start, dest_end)
        );
    if (need_alloca) {
        uint8_t *tmp = __builtin_alloca(src_arr_len * size);
        __builtin_memcpy(tmp, src_arr, src_arr_len * size);
        src_arr = tmp;
    }
    int32_t src_ind = src_start;
    int32_t dest_ind = dest_start;
    for (;
        (src_step > 0) ? (src_ind <= src_end) : (src_ind >= src_end);
        src_ind += src_step, dest_ind += dest_step
    ) {
        /* for constant optimization */
        if (size == 1) {
            __builtin_memcpy(dest_arr + dest_ind, src_arr + src_ind, 1);
        } else if (size == 4) {
            __builtin_memcpy(dest_arr + dest_ind * 4, src_arr + src_ind * 4, 4);
        } else if (size == 8) {
            __builtin_memcpy(dest_arr + dest_ind * 8, src_arr + src_ind * 8, 8);
        } else {
            /* memcpy for var size, cannot overlap after previous alloca */
            __builtin_memcpy(dest_arr + dest_ind * size, src_arr + src_ind * size, size);
        }
    }
    /* only dest_step == 1 can we shrink the dest list. */
    /* size should be ensured prior to calling this function */
    if (dest_step == 1 && dest_end >= dest_start) {
        __builtin_memmove(
            dest_arr + dest_ind * size,
            dest_arr + (dest_end + 1) * size,
            (dest_arr_len - dest_end - 1) * size
        );
        return dest_arr_len - (dest_end - dest_ind) - 1;
    }
    return dest_arr_len;
 }
 int32_t __nac3_isinf(double x) {
    return __builtin_isinf(x);
 }
 int32_t __nac3_isnan(double x) {
    return __builtin_isnan(x);
 }
 double tgamma(double arg);
 double __nac3_gamma(double z) {
    // Handling for denormals
    //     | x                 | Python gamma(x) | C tgamma(x) |
    // --- | ----------------- | --------------- | ----------- |
    // (1) | nan               | nan             | nan         |
    // (2) | -inf              | -inf            | inf         |
    // (3) | inf               | inf             | inf         |
    // (4) | 0.0               | inf             | inf         |
    // (5) | {-1.0, -2.0, ...} | inf             | nan         |
    // (1)-(3)
    if (__builtin_isinf(z) || __builtin_isnan(z)) {
        return z;
    }
    double v = tgamma(z);
    // (4)-(5)
    return __builtin_isinf(v) || __builtin_isnan(v) ? __builtin_inf() : v;
 }
 double lgamma(double arg);
 double __nac3_gammaln(double x) {
    // libm's handling of value overflows differs from scipy:
    // - scipy: gammaln(-inf) -> -inf
    // - libm : lgamma(-inf) -> inf
    if (__builtin_isinf(x)) {
        return x;
    }
    return lgamma(x);
 }
 double j0(double x);
 double __nac3_j0(double x) {
    // libm's handling of value overflows differs from scipy:
    // - scipy: j0(inf) -> nan
    // - libm : j0(inf) -> 0.0
    if (__builtin_isinf(x)) {
        return __builtin_nan("");
    }
    return j0(x);
 }
 uint32_t __nac3_ndarray_calc_size(
    const uint64_t *list_data,
    uint32_t list_len,
    uint32_t begin_idx,
    uint32_t end_idx
 ) {
    __builtin_assume(end_idx <= list_len);
    uint32_t num_elems = 1;
    for (uint32_t i = begin_idx; i < end_idx; ++i) {
        uint64_t val = list_data[i];
        __builtin_assume(val > 0);
        num_elems *= val;
    }
    return num_elems;
 }
 uint64_t __nac3_ndarray_calc_size64(
    const uint64_t *list_data,
    uint64_t list_len,
    uint64_t begin_idx,
    uint64_t end_idx
 ) {
    __builtin_assume(end_idx <= list_len);
    uint64_t num_elems = 1;
    for (uint64_t i = begin_idx; i < end_idx; ++i) {
        uint64_t val = list_data[i];
        __builtin_assume(val > 0);
       num_elems *= val;
    }
    return num_elems;
 }
 void __nac3_ndarray_calc_nd_indices(
    uint32_t index,
    const uint32_t* dims,
    uint32_t num_dims,
    uint32_t* idxs
 ) {
    uint32_t stride = 1;
    for (uint32_t dim = 0; dim < num_dims; dim++) {
        uint32_t i = num_dims - dim - 1;
        __builtin_assume(dims[i] > 0);
        idxs[i] = (index / stride) % dims[i];
        stride *= dims[i];
    }
 }
 void __nac3_ndarray_calc_nd_indices64(
    uint64_t index,
    const uint64_t* dims,
    uint64_t num_dims,
    uint32_t* idxs
 ) {
    uint64_t stride = 1;
    for (uint64_t dim = 0; dim < num_dims; dim++) {
        uint64_t i = num_dims - dim - 1;
        __builtin_assume(dims[i] > 0);
        idxs[i] = (uint32_t) ((index / stride) % dims[i]);
        stride *= dims[i];
    }
 }
 uint32_t __nac3_ndarray_flatten_index(
    const uint32_t* dims,
    uint32_t num_dims,
    const uint32_t* indices,
    uint32_t num_indices
 ) {
    uint32_t idx = 0;
    uint32_t stride = 1;
    for (uint32_t i = 0; i < num_dims; ++i) {
        uint32_t ri = num_dims - i - 1;
        if (ri < num_indices) {
            idx += (stride * indices[ri]);
        }
        __builtin_assume(dims[i] > 0);
        stride *= dims[ri];
    }
    return idx;
 }
 uint64_t __nac3_ndarray_flatten_index64(
    const uint64_t* dims,
    uint64_t num_dims,
    const uint32_t* indices,
    uint64_t num_indices
 ) {
    uint64_t idx = 0;
    uint64_t stride = 1;
    for (uint64_t i = 0; i < num_dims; ++i) {
        uint64_t ri = num_dims - i - 1;
        if (ri < num_indices) {
            idx += (stride * indices[ri]);
        }
        __builtin_assume(dims[i] > 0);
        stride *= dims[ri];
    }
    return idx;
 }
 void __nac3_ndarray_calc_broadcast(
    const uint32_t *lhs_dims,
    uint32_t lhs_ndims,
    const uint32_t *rhs_dims,
    uint32_t rhs_ndims,
    uint32_t *out_dims
 ) {
    uint32_t max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
    for (uint32_t i = 0; i < max_ndims; ++i) {
        uint32_t *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : NULL;
        uint32_t *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : NULL;
        uint32_t *out_dim = &out_dims[max_ndims - i - 1];
        if (lhs_dim_sz == NULL) {
            *out_dim = *rhs_dim_sz;
        } else if (rhs_dim_sz == NULL) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == 1) {
            *out_dim = *rhs_dim_sz;
        } else if (*rhs_dim_sz == 1) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == *rhs_dim_sz) {
            *out_dim = *lhs_dim_sz;
        } else {
            __builtin_unreachable();
        }
    }
 }
 void __nac3_ndarray_calc_broadcast64(
    const uint64_t *lhs_dims,
    uint64_t lhs_ndims,
    const uint64_t *rhs_dims,
    uint64_t rhs_ndims,
    uint64_t *out_dims
 ) {
    uint64_t max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
    for (uint64_t i = 0; i < max_ndims; ++i) {
        uint64_t *lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : NULL;
        uint64_t *rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : NULL;
        uint64_t *out_dim = &out_dims[max_ndims - i - 1];
        if (lhs_dim_sz == NULL) {
            *out_dim = *rhs_dim_sz;
        } else if (rhs_dim_sz == NULL) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == 1) {
            *out_dim = *rhs_dim_sz;
        } else if (*rhs_dim_sz == 1) {
            *out_dim = *lhs_dim_sz;
        } else if (*lhs_dim_sz == *rhs_dim_sz) {
            *out_dim = *lhs_dim_sz;
        } else {
            __builtin_unreachable();
        }
    }
 }
 void __nac3_ndarray_calc_broadcast_idx(
    const uint32_t *src_dims,
    uint32_t src_ndims,
    const uint32_t *in_idx,
    uint32_t *out_idx
 ) {
    for (uint32_t i = 0; i < src_ndims; ++i) {
        uint32_t src_i = src_ndims - i - 1;
        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
    }
 }
 void __nac3_ndarray_calc_broadcast_idx64(
    const uint64_t *src_dims,
    uint64_t src_ndims,
    const uint32_t *in_idx,
    uint32_t *out_idx
 ) {
    for (uint64_t i = 0; i < src_ndims; ++i) {
        uint64_t src_i = src_ndims - i - 1;
        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : (uint32_t) in_idx[src_i];
    }
 }
--- a/nac3core/src/codegen/irrt/mod.rs
+++ b/nac3core/src/codegen/irrt/mod.rs
@ -1,28 +1,29 @@
-use crate::typecheck::typedef::Type;
+use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
 use super::{
    classes::{
        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
-        TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
+        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
    },
-    llvm_intrinsics, CodeGenContext, CodeGenerator,
+    llvm_intrinsics,
    macros::codegen_unreachable,
    stmt::gen_for_callback_incrementing,
    CodeGenContext, CodeGenerator,
 };
 use crate::codegen::classes::TypedArrayLikeAccessor;
 use crate::codegen::stmt::gen_for_callback_incrementing;
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    context::Context,
    memory_buffer::MemoryBuffer,
    module::Module,
    types::{BasicTypeEnum, IntType},
-    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
+    values::{BasicValue, BasicValueEnum, CallSiteValue, FloatValue, IntValue},
    AddressSpace, IntPredicate,
 };
 use itertools::Either;
 use nac3parser::ast::Expr;
 #[must_use]
-pub fn load_irrt(ctx: &Context) -> Module {
+pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver) -> Module<'ctx> {
    let bitcode_buf = MemoryBuffer::create_from_memory_range(
        include_bytes!(concat!(env!("OUT_DIR"), "/irrt.bc")),
        "irrt_bitcode_buffer",
@ -38,6 +39,25 @@ pub fn load_irrt(ctx: &Context) -> Module {
        let function = irrt_mod.get_function(symbol).unwrap();
        function.add_attribute(AttributeLoc::Function, ctx.create_enum_attribute(inline_attr, 0));
    }
    // Initialize all global `EXN_*` exception IDs in IRRT with the [`SymbolResolver`].
    let exn_id_type = ctx.i32_type();
    let errors = &[
        ("EXN_INDEX_ERROR", "0:IndexError"),
        ("EXN_VALUE_ERROR", "0:ValueError"),
        ("EXN_ASSERTION_ERROR", "0:AssertionError"),
        ("EXN_TYPE_ERROR", "0:TypeError"),
    ];
    for (irrt_name, symbol_name) in errors {
        let exn_id = symbol_resolver.get_string_id(symbol_name);
        let exn_id = exn_id_type.const_int(exn_id as u64, false).as_basic_value_enum();
        let global = irrt_mod.get_global(irrt_name).unwrap_or_else(|| {
            panic!("Exception symbol name '{irrt_name}' should exist in the IRRT LLVM module")
        });
        global.set_initializer(&exn_id);
    }
    irrt_mod
 }
@ -55,7 +75,7 @@ pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
        (64, 64, true) => "__nac3_int_exp_int64_t",
        (32, 32, false) => "__nac3_int_exp_uint32_t",
        (64, 64, false) => "__nac3_int_exp_uint64_t",
-        _ => unreachable!(),
+        _ => codegen_unreachable!(ctx),
    };
    let base_type = base.get_type();
    let pow_fun = ctx.module.get_function(symbol).unwrap_or_else(|| {
@ -441,7 +461,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
                    BasicTypeEnum::IntType(t) => t.size_of(),
                    BasicTypeEnum::PointerType(t) => t.size_of(),
                    BasicTypeEnum::StructType(t) => t.size_of().unwrap(),
-                    _ => unreachable!(),
+                    _ => codegen_unreachable!(ctx),
                };
                ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size").unwrap()
            }
@ -568,7 +588,8 @@ pub fn call_j0<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> Flo
 ///
 /// * `dims` - An [`ArrayLikeIndexer`] containing the size of each dimension.
 /// * `range` - The dimension index to begin and end (exclusively) calculating the dimensions for,
-/// or [`None`] if starting from the first dimension and ending at the last dimension respectively.
+///   or [`None`] if starting from the first dimension and ending at the last dimension
 ///   respectively.
 pub fn call_ndarray_calc_size<'ctx, G, Dims>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
@ -579,18 +600,16 @@ where
    G: CodeGenerator + ?Sized,
    Dims: ArrayLikeIndexer<'ctx>,
 {
    let llvm_i64 = ctx.ctx.i64_type();
    let llvm_usize = generator.get_size_type(ctx.ctx);
-
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
    let llvm_pi64 = llvm_i64.ptr_type(AddressSpace::default());
    let ndarray_calc_size_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_size",
        64 => "__nac3_ndarray_calc_size64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_size_fn_t = llvm_usize.fn_type(
-        &[llvm_pi64.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
+        &[llvm_pusize.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
        false,
    );
    let ndarray_calc_size_fn =
@ -638,7 +657,7 @@ pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
    let ndarray_calc_nd_indices_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_nd_indices",
        64 => "__nac3_ndarray_calc_nd_indices64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_nd_indices_fn =
        ctx.module.get_function(ndarray_calc_nd_indices_fn_name).unwrap_or_else(|| {
@ -707,7 +726,7 @@ where
    let ndarray_flatten_index_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_flatten_index",
        64 => "__nac3_ndarray_flatten_index64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_flatten_index_fn =
        ctx.module.get_function(ndarray_flatten_index_fn_name).unwrap_or_else(|| {
@ -775,7 +794,7 @@ pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_broadcast",
        64 => "__nac3_ndarray_calc_broadcast64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_broadcast_fn =
        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
@ -800,6 +819,7 @@ pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
    gen_for_callback_incrementing(
        generator,
        ctx,
        None,
        llvm_usize.const_zero(),
        (min_ndims, false),
        |generator, ctx, _, idx| {
@ -894,7 +914,7 @@ pub fn call_ndarray_calc_broadcast_index<
    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
        32 => "__nac3_ndarray_calc_broadcast_idx",
        64 => "__nac3_ndarray_calc_broadcast_idx64",
-        bw => unreachable!("Unsupported size type bit width: {}", bw),
+        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
    };
    let ndarray_calc_broadcast_fn =
        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
--- a/nac3core/src/codegen/llvm_intrinsics.rs
+++ b/nac3core/src/codegen/llvm_intrinsics.rs
@ -35,6 +35,40 @@ fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
    unreachable!()
 }
 /// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
 /// intrinsic.
 pub fn call_va_start<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
    const FN_NAME: &str = "llvm.va_start";
    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let llvm_void = ctx.ctx.void_type();
        let llvm_i8 = ctx.ctx.i8_type();
        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
        ctx.module.add_function(FN_NAME, fn_type, None)
    });
    ctx.builder.build_call(intrinsic_fn, &[arglist.into()], "").unwrap();
 }
 /// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
 /// intrinsic.
 pub fn call_va_end<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
    const FN_NAME: &str = "llvm.va_end";
    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let llvm_void = ctx.ctx.void_type();
        let llvm_i8 = ctx.ctx.i8_type();
        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
        ctx.module.add_function(FN_NAME, fn_type, None)
    });
    ctx.builder.build_call(intrinsic_fn, &[arglist.into()], "").unwrap();
 }
 /// Invokes the [`llvm.stacksave`](https://llvm.org/docs/LangRef.html#llvm-stacksave-intrinsic)
 /// intrinsic.
 pub fn call_stacksave<'ctx>(
@ -62,145 +96,30 @@ pub fn call_stacksave<'ctx>(
 pub fn call_stackrestore<'ctx>(ctx: &CodeGenContext<'ctx, '_>, ptr: PointerValue<'ctx>) {
    const FN_NAME: &str = "llvm.stackrestore";
-    let llvm_i8 = ctx.ctx.i8_type();
+    /*
-    let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
+        SEE https://github.com/TheDan64/inkwell/issues/496
        We want `llvm.stackrestore`, but the following would generate `llvm.stackrestore.p0i8`.
        ```ignore
        let intrinsic_fn = Intrinsic::find(FN_NAME)
            .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_p0i8.into()]))
            .unwrap();
        ```
        Temp workaround by manually declaring the intrinsic with the correct function name instead.
    */
    let intrinsic_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
        let llvm_void = ctx.ctx.void_type();
        let llvm_i8 = ctx.ctx.i8_type();
        let llvm_p0i8 = llvm_i8.ptr_type(AddressSpace::default());
        let fn_type = llvm_void.fn_type(&[llvm_p0i8.into()], false);
        ctx.module.add_function(FN_NAME, fn_type, None)
    });
    ctx.builder.build_call(intrinsic_fn, &[ptr.into()], "").unwrap();
 }
 /// Invokes the [`llvm.abs`](https://llvm.org/docs/LangRef.html#llvm-abs-intrinsic) intrinsic.
 ///
 /// * `src` - The value for which the absolute value is to be returned.
 /// * `is_int_min_poison` - Whether `poison` is to be returned if `src` is `INT_MIN`.
 pub fn call_int_abs<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    src: IntValue<'ctx>,
    is_int_min_poison: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.abs";
    debug_assert_eq!(is_int_min_poison.get_type().get_bit_width(), 1);
    debug_assert!(is_int_min_poison.is_const());
    let llvm_src_t = src.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_src_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[src.into(), is_int_min_poison.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.smax`](https://llvm.org/docs/LangRef.html#llvm-smax-intrinsic) intrinsic.
 pub fn call_int_smax<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    a: IntValue<'ctx>,
    b: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.smax";
    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
    let llvm_int_t = a.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_int_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.smin`](https://llvm.org/docs/LangRef.html#llvm-smin-intrinsic) intrinsic.
 pub fn call_int_smin<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    a: IntValue<'ctx>,
    b: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.smin";
    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
    let llvm_int_t = a.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_int_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.umax`](https://llvm.org/docs/LangRef.html#llvm-umax-intrinsic) intrinsic.
 pub fn call_int_umax<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    a: IntValue<'ctx>,
    b: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.umax";
    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
    let llvm_int_t = a.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_int_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.umin`](https://llvm.org/docs/LangRef.html#llvm-umin-intrinsic) intrinsic.
 pub fn call_int_umin<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    a: IntValue<'ctx>,
    b: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.umin";
    debug_assert_eq!(a.get_type().get_bit_width(), b.get_type().get_bit_width());
    let llvm_int_t = a.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_int_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[a.into(), b.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.memcpy`](https://llvm.org/docs/LangRef.html#llvm-memcpy-intrinsic) intrinsic.
 ///
 /// * `dest` - The pointer to the destination. Must be a pointer to an integer type.
@ -264,7 +183,7 @@ pub fn call_memcpy_generic<'ctx>(
        dest
    } else {
        ctx.builder
-            .build_bitcast(dest, llvm_p0i8, "")
+            .build_bit_cast(dest, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
@ -272,7 +191,7 @@ pub fn call_memcpy_generic<'ctx>(
        src
    } else {
        ctx.builder
-            .build_bitcast(src, llvm_p0i8, "")
+            .build_bit_cast(src, llvm_p0i8, "")
            .map(BasicValueEnum::into_pointer_value)
            .unwrap()
    };
@ -280,27 +199,122 @@ pub fn call_memcpy_generic<'ctx>(
    call_memcpy(ctx, dest, src, len, is_volatile);
 }
-/// Invokes the [`llvm.sqrt`](https://llvm.org/docs/LangRef.html#llvm-sqrt-intrinsic) intrinsic.
+/// Macro to find and generate build call for llvm intrinsic (body of llvm intrinsic function)
-pub fn call_float_sqrt<'ctx>(
+///
 /// Arguments:
 /// * `$ctx:ident`: Reference to the current Code Generation Context
 /// * `$name:ident`: Optional name to be assigned to the llvm build call (Option<&str>)
 /// * `$llvm_name:literal`: Name of underlying llvm intrinsic function
 /// * `$map_fn:ident`: Mapping function to be applied on `BasicValue` (`BasicValue` -> Function Return Type).
 ///   Use `BasicValueEnum::into_int_value` for Integer return type and
 ///   `BasicValueEnum::into_float_value` for Float return type
 /// * `$llvm_ty:ident`: Type of first operand
 /// * `,($val:ident)*`: Comma separated list of operands
 macro_rules! generate_llvm_intrinsic_fn_body {
    ($ctx:ident, $name:ident, $llvm_name:literal, $map_fn:expr, $llvm_ty:ident $(,$val:ident)*) => {{
        const FN_NAME: &str = concat!("llvm.", $llvm_name);
        let intrinsic_fn = Intrinsic::find(FN_NAME).and_then(|intrinsic| intrinsic.get_declaration(&$ctx.module, &[$llvm_ty.into()])).unwrap();
        $ctx.builder.build_call(intrinsic_fn, &[$($val.into()),*],  $name.unwrap_or_default()).map(CallSiteValue::try_as_basic_value).map(|v| v.map_left($map_fn)).map(Either::unwrap_left).unwrap()
    }};
 }
 /// Macro to generate the llvm intrinsic function using [`generate_llvm_intrinsic_fn_body`].
 ///
 /// Arguments:
 /// * `float/int`: Indicates the return and argument type of the function
 /// * `$fn_name:ident`: The identifier of the rust function to be generated
 /// * `$llvm_name:literal`: Name of underlying llvm intrinsic function.
 ///   Omit "llvm." prefix from the function name i.e. use "ceil" instead of "llvm.ceil"
 /// * `$val:ident`: The operand for unary operations
 /// * `$val1:ident`, `$val2:ident`: The operands for binary operations
 macro_rules! generate_llvm_intrinsic_fn {
    ("float", $fn_name:ident, $llvm_name:literal, $val:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
-    val: FloatValue<'ctx>,
+            $val: FloatValue<'ctx>,
            name: Option<&str>,
        ) -> FloatValue<'ctx> {
-    const FN_NAME: &str = "llvm.sqrt";
+            let llvm_ty = $val.get_type();
-
+            generate_llvm_intrinsic_fn_body!(ctx, name, $llvm_name, BasicValueEnum::into_float_value, llvm_ty, $val)
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
        }
    };
    ("float", $fn_name:ident, $llvm_name:literal, $val1:ident, $val2:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
            $val1: FloatValue<'ctx>,
            $val2: FloatValue<'ctx>,
            name: Option<&str>,
        ) -> FloatValue<'ctx> {
            debug_assert_eq!($val1.get_type(), $val2.get_type());
            let llvm_ty = $val1.get_type();
            generate_llvm_intrinsic_fn_body!(ctx, name, $llvm_name, BasicValueEnum::into_float_value, llvm_ty, $val1, $val2)
        }
    };
    ("int", $fn_name:ident, $llvm_name:literal, $val1:ident, $val2:ident) => {
        #[doc = concat!("Invokes the [`", stringify!($llvm_name), "`](https://llvm.org/docs/LangRef.html#llvm-", stringify!($llvm_name), "-intrinsic) intrinsic." )]
        pub fn $fn_name<'ctx> (
            ctx: &CodeGenContext<'ctx, '_>,
            $val1: IntValue<'ctx>,
            $val2: IntValue<'ctx>,
            name: Option<&str>,
        ) -> IntValue<'ctx> {
            debug_assert_eq!($val1.get_type().get_bit_width(), $val2.get_type().get_bit_width());
            let llvm_ty = $val1.get_type();
            generate_llvm_intrinsic_fn_body!(ctx, name, $llvm_name, BasicValueEnum::into_int_value, llvm_ty, $val1, $val2)
        }
    };
 }
 /// Invokes the [`llvm.abs`](https://llvm.org/docs/LangRef.html#llvm-abs-intrinsic) intrinsic.
 ///
 /// * `src` - The value for which the absolute value is to be returned.
 /// * `is_int_min_poison` - Whether `poison` is to be returned if `src` is `INT_MIN`.
 pub fn call_int_abs<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    src: IntValue<'ctx>,
    is_int_min_poison: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    debug_assert_eq!(is_int_min_poison.get_type().get_bit_width(), 1);
    debug_assert!(is_int_min_poison.is_const());
    let src_type = src.get_type();
    generate_llvm_intrinsic_fn_body!(
        ctx,
        name,
        "abs",
        BasicValueEnum::into_int_value,
        src_type,
        src,
        is_int_min_poison
    )
 }
 generate_llvm_intrinsic_fn!("int", call_int_smax, "smax", a, b);
 generate_llvm_intrinsic_fn!("int", call_int_smin, "smin", a, b);
 generate_llvm_intrinsic_fn!("int", call_int_umax, "umax", a, b);
 generate_llvm_intrinsic_fn!("int", call_int_umin, "umin", a, b);
 generate_llvm_intrinsic_fn!("int", call_expect, "expect", val, expected_val);
 generate_llvm_intrinsic_fn!("float", call_float_sqrt, "sqrt", val);
 generate_llvm_intrinsic_fn!("float", call_float_sin, "sin", val);
 generate_llvm_intrinsic_fn!("float", call_float_cos, "cos", val);
 generate_llvm_intrinsic_fn!("float", call_float_pow, "pow", val, power);
 generate_llvm_intrinsic_fn!("float", call_float_exp, "exp", val);
 generate_llvm_intrinsic_fn!("float", call_float_exp2, "exp2", val);
 generate_llvm_intrinsic_fn!("float", call_float_log, "log", val);
 generate_llvm_intrinsic_fn!("float", call_float_log10, "log10", val);
 generate_llvm_intrinsic_fn!("float", call_float_log2, "log2", val);
 generate_llvm_intrinsic_fn!("float", call_float_fabs, "fabs", src);
 generate_llvm_intrinsic_fn!("float", call_float_minnum, "minnum", val, power);
 generate_llvm_intrinsic_fn!("float", call_float_maxnum, "maxnum", val, power);
 generate_llvm_intrinsic_fn!("float", call_float_copysign, "copysign", mag, sgn);
 generate_llvm_intrinsic_fn!("float", call_float_floor, "floor", val);
 generate_llvm_intrinsic_fn!("float", call_float_ceil, "ceil", val);
 generate_llvm_intrinsic_fn!("float", call_float_round, "round", val);
 generate_llvm_intrinsic_fn!("float", call_float_rint, "rint", val);
 /// Invokes the [`llvm.powi`](https://llvm.org/docs/LangRef.html#llvm-powi-intrinsic) intrinsic.
 pub fn call_float_powi<'ctx>(
@ -327,393 +341,3 @@ pub fn call_float_powi<'ctx>(
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.sin`](https://llvm.org/docs/LangRef.html#llvm-sin-intrinsic) intrinsic.
 pub fn call_float_sin<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.sin";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.cos`](https://llvm.org/docs/LangRef.html#llvm-cos-intrinsic) intrinsic.
 pub fn call_float_cos<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.cos";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.pow`](https://llvm.org/docs/LangRef.html#llvm-pow-intrinsic) intrinsic.
 pub fn call_float_pow<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    power: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.pow";
    debug_assert_eq!(val.get_type(), power.get_type());
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into(), power.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.exp`](https://llvm.org/docs/LangRef.html#llvm-exp-intrinsic) intrinsic.
 pub fn call_float_exp<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.exp";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.exp2`](https://llvm.org/docs/LangRef.html#llvm-exp2-intrinsic) intrinsic.
 pub fn call_float_exp2<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.exp2";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.log`](https://llvm.org/docs/LangRef.html#llvm-log-intrinsic) intrinsic.
 pub fn call_float_log<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.log";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.log10`](https://llvm.org/docs/LangRef.html#llvm-log10-intrinsic) intrinsic.
 pub fn call_float_log10<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.log10";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.log2`](https://llvm.org/docs/LangRef.html#llvm-log2-intrinsic) intrinsic.
 pub fn call_float_log2<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.log2";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.fabs`](https://llvm.org/docs/LangRef.html#llvm-fabs-intrinsic) intrinsic.
 pub fn call_float_fabs<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    src: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.fabs";
    let llvm_src_t = src.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_src_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[src.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.minnum`](https://llvm.org/docs/LangRef.html#llvm-minnum-intrinsic) intrinsic.
 pub fn call_float_minnum<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val1: FloatValue<'ctx>,
    val2: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.minnum";
    debug_assert_eq!(val1.get_type(), val2.get_type());
    let llvm_float_t = val1.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val1.into(), val2.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.maxnum`](https://llvm.org/docs/LangRef.html#llvm-maxnum-intrinsic) intrinsic.
 pub fn call_float_maxnum<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val1: FloatValue<'ctx>,
    val2: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.maxnum";
    debug_assert_eq!(val1.get_type(), val2.get_type());
    let llvm_float_t = val1.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val1.into(), val2.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.copysign`](https://llvm.org/docs/LangRef.html#llvm-copysign-intrinsic) intrinsic.
 pub fn call_float_copysign<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    mag: FloatValue<'ctx>,
    sgn: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.copysign";
    debug_assert_eq!(mag.get_type(), sgn.get_type());
    let llvm_float_t = mag.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[mag.into(), sgn.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.floor`](https://llvm.org/docs/LangRef.html#llvm-floor-intrinsic) intrinsic.
 pub fn call_float_floor<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.floor";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.ceil`](https://llvm.org/docs/LangRef.html#llvm-ceil-intrinsic) intrinsic.
 pub fn call_float_ceil<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.ceil";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.round`](https://llvm.org/docs/LangRef.html#llvm-round-intrinsic) intrinsic.
 pub fn call_float_round<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.round";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the
 /// [`llvm.roundeven`](https://llvm.org/docs/LangRef.html#llvm-roundeven-intrinsic) intrinsic.
 pub fn call_float_roundeven<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: FloatValue<'ctx>,
    name: Option<&str>,
 ) -> FloatValue<'ctx> {
    const FN_NAME: &str = "llvm.roundeven";
    let llvm_float_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_float_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_float_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Invokes the [`llvm.expect`](https://llvm.org/docs/LangRef.html#llvm-expect-intrinsic) intrinsic.
 pub fn call_expect<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    val: IntValue<'ctx>,
    expected_val: IntValue<'ctx>,
    name: Option<&str>,
 ) -> IntValue<'ctx> {
    const FN_NAME: &str = "llvm.expect";
    debug_assert_eq!(val.get_type().get_bit_width(), expected_val.get_type().get_bit_width());
    let llvm_int_t = val.get_type();
    let intrinsic_fn = Intrinsic::find(FN_NAME)
        .and_then(|intrinsic| intrinsic.get_declaration(&ctx.module, &[llvm_int_t.into()]))
        .unwrap();
    ctx.builder
        .build_call(intrinsic_fn, &[val.into(), expected_val.into()], name.unwrap_or_default())
        .map(CallSiteValue::try_as_basic_value)
        .map(|v| v.map_left(BasicValueEnum::into_int_value))
        .map(Either::unwrap_left)
        .unwrap()
 }
--- a/nac3core/src/codegen/mod.rs
+++ b/nac3core/src/codegen/mod.rs
@ -50,6 +50,22 @@ mod test;
 use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
 pub use generator::{CodeGenerator, DefaultCodeGenerator};
 mod macros {
    /// Codegen-variant of [`std::unreachable`] which accepts an instance of [`CodeGenContext`] as
    /// its first argument to provide Python source information to indicate the codegen location
    /// causing the assertion.
    macro_rules! codegen_unreachable {
        ($ctx:expr $(,)?) => {
            std::unreachable!("unreachable code while processing {}", &$ctx.current_loc)
        };
        ($ctx:expr, $($arg:tt)*) => {
            std::unreachable!("unreachable code while processing {}: {}", &$ctx.current_loc, std::format!("{}", std::format_args!($($arg)+)))
        };
    }
    pub(crate) use codegen_unreachable;
 }
 #[derive(Default)]
 pub struct StaticValueStore {
    pub lookup: HashMap<Vec<(usize, u64)>, usize>,
@ -68,6 +84,16 @@ pub struct CodeGenLLVMOptions {
    pub target: CodeGenTargetMachineOptions,
 }
 impl CodeGenLLVMOptions {
    /// Creates a [`TargetMachine`] using the target options specified by this struct.
    ///
    /// See [`Target::create_target_machine`].
    #[must_use]
    pub fn create_target_machine(&self) -> Option<TargetMachine> {
        self.target.create_target_machine(self.opt_level)
    }
 }
 /// Additional options for code generation for the target machine.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct CodeGenTargetMachineOptions {
@ -338,6 +364,10 @@ impl WorkerRegistry {
        let mut builder = context.create_builder();
        let mut module = context.create_module(generator.get_name());
        let target_machine = self.llvm_options.create_target_machine().unwrap();
        module.set_data_layout(&target_machine.get_target_data().get_data_layout());
        module.set_triple(&target_machine.get_triple());
        module.add_basic_value_flag(
            "Debug Info Version",
            inkwell::module::FlagBehavior::Warning,
@ -361,6 +391,10 @@ impl WorkerRegistry {
                    errors.insert(e);
                    // create a new empty module just to continue codegen and collect errors
                    module = context.create_module(&format!("{}_recover", generator.get_name()));
                    let target_machine = self.llvm_options.create_target_machine().unwrap();
                    module.set_data_layout(&target_machine.get_target_data().get_data_layout());
                    module.set_triple(&target_machine.get_triple());
                }
            }
            *self.task_count.lock() -= 1;
@ -426,7 +460,7 @@ pub struct CodeGenTask {
 fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &'ctx Context,
    module: &Module<'ctx>,
-    generator: &mut G,
+    generator: &G,
    unifier: &mut Unifier,
    top_level: &TopLevelContext,
    type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
@ -456,6 +490,20 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                            .into()
                        }
                        TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
                            let element_type = get_llvm_type(
                                ctx,
                                module,
                                generator,
                                unifier,
                                top_level,
                                type_cache,
                                *params.iter().next().unwrap().1,
                            );
                            ListType::new(generator, ctx, element_type).as_base_type().into()
                        }
                        TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
                            let (dtype, _) = unpack_ndarray_var_tys(unifier, ty);
                            let element_type = get_llvm_type(
@ -506,8 +554,10 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                };
                return ty;
            }
-            TTuple { ty } => {
+            TTuple { ty, is_vararg_ctx } => {
                // a struct with fields in the order present in the tuple
                assert!(!is_vararg_ctx, "Tuples in vararg context must be instantiated with the correct number of arguments before calling get_llvm_type");
                let fields = ty
                    .iter()
                    .map(|ty| {
@ -516,12 +566,6 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                    .collect_vec();
                ctx.struct_type(&fields, false).into()
            }
            TList { ty } => {
                let element_type =
                    get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, *ty);
                ListType::new(generator, ctx, element_type).as_base_type().into()
            }
            TVirtual { .. } => unimplemented!(),
            _ => unreachable!("{}", ty_enum.get_type_name()),
        };
@ -543,7 +587,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
 fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &'ctx Context,
    module: &Module<'ctx>,
-    generator: &mut G,
+    generator: &G,
    unifier: &mut Unifier,
    top_level: &TopLevelContext,
    type_cache: &mut HashMap<Type, BasicTypeEnum<'ctx>>,
@ -552,11 +596,11 @@ fn get_llvm_abi_type<'ctx, G: CodeGenerator + ?Sized>(
 ) -> BasicTypeEnum<'ctx> {
    // If the type is used in the definition of a function, return `i1` instead of `i8` for ABI
    // consistency.
-    return if unifier.unioned(ty, primitives.bool) {
+    if unifier.unioned(ty, primitives.bool) {
        ctx.bool_type().into()
    } else {
        get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, ty)
-    };
+    }
 }
 /// Whether `sret` is needed for a return value with type `ty`.
@ -581,6 +625,40 @@ fn need_sret(ty: BasicTypeEnum) -> bool {
    need_sret_impl(ty, true)
 }
 /// Returns the [`BasicTypeEnum`] representing a `va_list` struct for variadic arguments.
 fn get_llvm_valist_type<'ctx>(ctx: &'ctx Context, triple: &TargetTriple) -> BasicTypeEnum<'ctx> {
    let triple = TargetMachine::normalize_triple(triple);
    let triple = triple.as_str().to_str().unwrap();
    let arch = triple.split('-').next().unwrap();
    let llvm_pi8 = ctx.i8_type().ptr_type(AddressSpace::default());
    // Referenced from parseArch() in llvm/lib/Support/Triple.cpp
    match arch {
        "i386" | "i486" | "i586" | "i686" | "riscv32" => {
            ctx.i8_type().ptr_type(AddressSpace::default()).into()
        }
        "amd64" | "x86_64" | "x86_64h" => {
            let llvm_i32 = ctx.i32_type();
            let va_list_tag = ctx.opaque_struct_type("struct.__va_list_tag");
            va_list_tag.set_body(
                &[llvm_i32.into(), llvm_i32.into(), llvm_pi8.into(), llvm_pi8.into()],
                false,
            );
            va_list_tag.into()
        }
        "armv7" => {
            let va_list = ctx.opaque_struct_type("struct.__va_list");
            va_list.set_body(&[llvm_pi8.into()], false);
            va_list.into()
        }
        triple => {
            todo!("Unsupported platform for varargs: {triple}")
        }
    }
 }
 /// Implementation for generating LLVM IR for a function.
 pub fn gen_func_impl<
    'ctx,
@ -692,6 +770,7 @@ pub fn gen_func_impl<
                name: arg.name,
                ty: task.store.to_unifier_type(&mut unifier, &primitives, arg.ty, &mut cache),
                default_value: arg.default_value.clone(),
                is_vararg: arg.is_vararg,
            })
            .collect_vec(),
        task.store.to_unifier_type(&mut unifier, &primitives, *ret, &mut cache),
@ -714,7 +793,10 @@ pub fn gen_func_impl<
    let has_sret = ret_type.map_or(false, |ty| need_sret(ty));
    let mut params = args
        .iter()
        .filter(|arg| !arg.is_vararg)
        .map(|arg| {
            debug_assert!(!arg.is_vararg);
            get_llvm_abi_type(
                context,
                &module,
@ -733,9 +815,12 @@ pub fn gen_func_impl<
        params.insert(0, ret_type.unwrap().ptr_type(AddressSpace::default()).into());
    }
    debug_assert!(matches!(args.iter().filter(|arg| arg.is_vararg).count(), 0..=1));
    let vararg_arg = args.iter().find(|arg| arg.is_vararg);
    let fn_type = match ret_type {
-        Some(ret_type) if !has_sret => ret_type.fn_type(&params, false),
+        Some(ret_type) if !has_sret => ret_type.fn_type(&params, vararg_arg.is_some()),
-        _ => context.void_type().fn_type(&params, false),
+        _ => context.void_type().fn_type(&params, vararg_arg.is_some()),
    };
    let symbol = &task.symbol_name;
@ -765,7 +850,9 @@ pub fn gen_func_impl<
    let mut var_assignment = HashMap::new();
    let offset = u32::from(has_sret);
-    for (n, arg) in args.iter().enumerate() {
+
    // Store non-vararg argument values into local variables
    for (n, arg) in args.iter().enumerate().filter(|(_, arg)| !arg.is_vararg) {
        let param = fn_val.get_nth_param((n as u32) + offset).unwrap();
        let local_type = get_llvm_type(
            context,
@ -798,6 +885,8 @@ pub fn gen_func_impl<
        var_assignment.insert(arg.name, (alloca, None, 0));
    }
    // TODO: Save vararg parameters as list
    let return_buffer = if has_sret {
        Some(fn_val.get_nth_param(0).unwrap().into_pointer_value())
    } else {
@ -1020,3 +1109,9 @@ fn gen_in_range_check<'ctx>(
    ctx.builder.build_int_compare(IntPredicate::SLT, lo, hi, "cmp").unwrap()
 }
 /// Returns the internal name for the `va_count` argument, used to indicate the number of arguments
 /// passed to the variadic function.
 fn get_va_count_arg_name(arg_name: StrRef) -> StrRef {
    format!("__{}_va_count", &arg_name).into()
 }
--- a/nac3core/src/codegen/numpy.rs
+++ b/nac3core/src/codegen/numpy.rs
--- a/nac3core/src/codegen/stmt.rs
+++ b/nac3core/src/codegen/stmt.rs
@ -1,17 +1,18 @@
 use super::{
-    super::symbol_resolver::ValueEnum,
+    classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
-    expr::destructure_range,
+    expr::{destructure_range, gen_binop_expr},
    gen_in_range_check,
    irrt::{handle_slice_indices, list_slice_assignment},
    macros::codegen_unreachable,
    CodeGenContext, CodeGenerator,
 };
 use crate::{
-    codegen::{
+    symbol_resolver::ValueEnum,
-        classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
+    toplevel::{DefinitionId, TopLevelDef},
-        expr::gen_binop_expr,
+    typecheck::{
-        gen_in_range_check,
+        magic_methods::Binop,
        typedef::{iter_type_vars, FunSignature, Type, TypeEnum},
    },
    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, DefinitionId, TopLevelDef},
    typecheck::typedef::{FunSignature, Type, TypeEnum},
 };
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -20,10 +21,10 @@ use inkwell::{
    values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
    IntPredicate,
 };
 use itertools::{izip, Itertools};
 use nac3parser::ast::{
    Constant, ExcepthandlerKind, Expr, ExprKind, Location, Stmt, StmtKind, StrRef,
 };
 use std::convert::TryFrom;
 /// See [`CodeGenerator::gen_var_alloc`].
 pub fn gen_var<'ctx>(
@ -94,8 +95,6 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
    pattern: &Expr<Option<Type>>,
    name: Option<&str>,
 ) -> Result<Option<PointerValue<'ctx>>, String> {
    let llvm_usize = generator.get_size_type(ctx.ctx);
    // very similar to gen_expr, but we don't do an extra load at the end
    // and we flatten nested tuples
    Ok(Some(match &pattern.node {
@ -113,14 +112,14 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
            }
        },
        ExprKind::Attribute { value, attr, .. } => {
-            let index = ctx.get_attr_index(value.custom.unwrap(), *attr);
+            let (index, _) = ctx.get_attr_index(value.custom.unwrap(), *attr);
            let val = if let Some(v) = generator.gen_expr(ctx, value)? {
                v.to_basic_value_enum(ctx, generator, value.custom.unwrap())?
            } else {
                return Ok(None);
            };
            let BasicValueEnum::PointerValue(ptr) = val else {
-                unreachable!();
+                codegen_unreachable!(ctx);
            };
            unsafe {
                ctx.builder.build_in_bounds_gep(
@ -134,66 +133,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
            }
            .unwrap()
        }
-        ExprKind::Subscript { value, slice, .. } => {
+        _ => codegen_unreachable!(ctx),
            match ctx.unifier.get_ty_immutable(value.custom.unwrap()).as_ref() {
                TypeEnum::TList { .. } => {
                    let v = generator
                        .gen_expr(ctx, value)?
                        .unwrap()
                        .to_basic_value_enum(ctx, generator, value.custom.unwrap())?
                        .into_pointer_value();
                    let v = ListValue::from_ptr_val(v, llvm_usize, None);
                    let len = v.load_size(ctx, Some("len"));
                    let raw_index = generator
                        .gen_expr(ctx, slice)?
                        .unwrap()
                        .to_basic_value_enum(ctx, generator, slice.custom.unwrap())?
                        .into_int_value();
                    let raw_index = ctx
                        .builder
                        .build_int_s_extend(raw_index, generator.get_size_type(ctx.ctx), "sext")
                        .unwrap();
                    // handle negative index
                    let is_negative = ctx
                        .builder
                        .build_int_compare(
                            IntPredicate::SLT,
                            raw_index,
                            generator.get_size_type(ctx.ctx).const_zero(),
                            "is_neg",
                        )
                        .unwrap();
                    let adjusted = ctx.builder.build_int_add(raw_index, len, "adjusted").unwrap();
                    let index = ctx
                        .builder
                        .build_select(is_negative, adjusted, raw_index, "index")
                        .map(BasicValueEnum::into_int_value)
                        .unwrap();
                    // unsigned less than is enough, because negative index after adjustment is
                    // bigger than the length (for unsigned cmp)
                    let bound_check = ctx
                        .builder
                        .build_int_compare(IntPredicate::ULT, index, len, "inbound")
                        .unwrap();
                    ctx.make_assert(
                        generator,
                        bound_check,
                        "0:IndexError",
                        "index {0} out of bounds 0:{1}",
                        [Some(raw_index), Some(len), None],
                        slice.location,
                    );
                    v.data().ptr_offset(ctx, generator, &index, name)
                }
                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
                    todo!()
                }
                _ => unreachable!(),
            }
        }
        _ => unreachable!(),
    }))
 }
@ -203,68 +143,20 @@ pub fn gen_assign<'ctx, G: CodeGenerator>(
    ctx: &mut CodeGenContext<'ctx, '_>,
    target: &Expr<Option<Type>>,
    value: ValueEnum<'ctx>,
    value_ty: Type,
 ) -> Result<(), String> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    // See https://docs.python.org/3/reference/simple_stmts.html#assignment-statements.
    match &target.node {
-        ExprKind::Tuple { elts, .. } => {
+        ExprKind::Subscript { value: target, slice: key, .. } => {
-            let BasicValueEnum::StructValue(v) =
+            // Handle "slicing" or "subscription"
-                value.to_basic_value_enum(ctx, generator, target.custom.unwrap())?
+            generator.gen_setitem(ctx, target, key, value, value_ty)?;
            else {
                unreachable!()
            };
            for (i, elt) in elts.iter().enumerate() {
                let v = ctx
                    .builder
                    .build_extract_value(v, u32::try_from(i).unwrap(), "struct_elem")
                    .unwrap();
                generator.gen_assign(ctx, elt, v.into())?;
        }
-        }
+        ExprKind::Tuple { elts, .. } | ExprKind::List { elts, .. } => {
-        ExprKind::Subscript { value: ls, slice, .. }
+            // Fold on `"[" [target_list] "]"` and `"(" [target_list] ")"`
-            if matches!(&slice.node, ExprKind::Slice { .. }) =>
+            generator.gen_assign_target_list(ctx, elts, value, value_ty)?;
        {
            let ExprKind::Slice { lower, upper, step } = &slice.node else { unreachable!() };
            let ls = generator
                .gen_expr(ctx, ls)?
                .unwrap()
                .to_basic_value_enum(ctx, generator, ls.custom.unwrap())?
                .into_pointer_value();
            let ls = ListValue::from_ptr_val(ls, llvm_usize, None);
            let Some((start, end, step)) =
                handle_slice_indices(lower, upper, step, ctx, generator, ls.load_size(ctx, None))?
            else {
                return Ok(());
            };
            let value = value
                .to_basic_value_enum(ctx, generator, target.custom.unwrap())?
                .into_pointer_value();
            let value = ListValue::from_ptr_val(value, llvm_usize, None);
            let ty = match &*ctx.unifier.get_ty_immutable(target.custom.unwrap()) {
                TypeEnum::TList { ty } => *ty,
                TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
                    unpack_ndarray_var_tys(&mut ctx.unifier, target.custom.unwrap()).0
                }
                _ => unreachable!(),
            };
            let ty = ctx.get_llvm_type(generator, ty);
            let Some(src_ind) = handle_slice_indices(
                &None,
                &None,
                &None,
                ctx,
                generator,
                value.load_size(ctx, None),
            )?
            else {
                return Ok(());
            };
            list_slice_assignment(generator, ctx, ty, ls, (start, end, step), value, src_ind);
        }
        _ => {
            // Handle attribute and direct variable assignments.
            let name = if let ExprKind::Name { id, .. } = &target.node {
                format!("{id}.addr")
            } else {
@ -282,19 +174,259 @@ pub fn gen_assign<'ctx, G: CodeGenerator>(
                }
            }
            let val = value.to_basic_value_enum(ctx, generator, target.custom.unwrap())?;
            // Perform i1 <-> i8 conversion as needed
            let val = if ctx.unifier.unioned(target.custom.unwrap(), ctx.primitives.bool) {
                generator.bool_to_i8(ctx, val.into_int_value()).into()
            } else {
                val
            };
            ctx.builder.build_store(ptr, val).unwrap();
        }
    };
    Ok(())
 }
 /// See [`CodeGenerator::gen_assign_target_list`].
 pub fn gen_assign_target_list<'ctx, G: CodeGenerator>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    targets: &Vec<Expr<Option<Type>>>,
    value: ValueEnum<'ctx>,
    value_ty: Type,
 ) -> Result<(), String> {
    // Deconstruct the tuple `value`
    let BasicValueEnum::StructValue(tuple) = value.to_basic_value_enum(ctx, generator, value_ty)?
    else {
        codegen_unreachable!(ctx)
    };
    // NOTE: Currently, RHS's type is forced to be a Tuple by the type inferencer.
    let TypeEnum::TTuple { ty: tuple_tys, .. } = &*ctx.unifier.get_ty(value_ty) else {
        codegen_unreachable!(ctx);
    };
    assert_eq!(tuple.get_type().count_fields() as usize, tuple_tys.len());
    let tuple = (0..tuple.get_type().count_fields())
        .map(|i| ctx.builder.build_extract_value(tuple, i, "item").unwrap())
        .collect_vec();
    // Find the starred target if it exists.
    let mut starred_target_index: Option<usize> = None; // Index of the "starred" target. If it exists, there may only be one.
    for (i, target) in targets.iter().enumerate() {
        if matches!(target.node, ExprKind::Starred { .. }) {
            assert!(starred_target_index.is_none()); // The typechecker ensures this
            starred_target_index = Some(i);
        }
    }
    if let Some(starred_target_index) = starred_target_index {
        assert!(tuple_tys.len() >= targets.len() - 1); // The typechecker ensures this
        let a = starred_target_index; // Number of RHS values before the starred target
        let b = tuple_tys.len() - (targets.len() - 1 - starred_target_index); // Number of RHS values after the starred target
                                                                              // Thus `tuple[a..b]` is assigned to the starred target.
        // Handle assignment before the starred target
        for (target, val, val_ty) in
            izip!(&targets[..starred_target_index], &tuple[..a], &tuple_tys[..a])
        {
            generator.gen_assign(ctx, target, ValueEnum::Dynamic(*val), *val_ty)?;
        }
        // Handle assignment to the starred target
        if let ExprKind::Starred { value: target, .. } = &targets[starred_target_index].node {
            let vals = &tuple[a..b];
            let val_tys = &tuple_tys[a..b];
            // Create a sub-tuple from `value` for the starred target.
            let sub_tuple_ty = ctx
                .ctx
                .struct_type(&vals.iter().map(BasicValueEnum::get_type).collect_vec(), false);
            let psub_tuple_val =
                ctx.builder.build_alloca(sub_tuple_ty, "starred_target_value_ptr").unwrap();
            for (i, val) in vals.iter().enumerate() {
                let pitem = ctx
                    .builder
                    .build_struct_gep(psub_tuple_val, i as u32, "starred_target_value_item")
                    .unwrap();
                ctx.builder.build_store(pitem, *val).unwrap();
            }
            let sub_tuple_val =
                ctx.builder.build_load(psub_tuple_val, "starred_target_value").unwrap();
            // Create the typechecker type of the sub-tuple
            let sub_tuple_ty =
                ctx.unifier.add_ty(TypeEnum::TTuple { ty: val_tys.to_vec(), is_vararg_ctx: false });
            // Now assign with that sub-tuple to the starred target.
            generator.gen_assign(ctx, target, ValueEnum::Dynamic(sub_tuple_val), sub_tuple_ty)?;
        } else {
            codegen_unreachable!(ctx) // The typechecker ensures this
        }
        // Handle assignment after the starred target
        for (target, val, val_ty) in
            izip!(&targets[starred_target_index + 1..], &tuple[b..], &tuple_tys[b..])
        {
            generator.gen_assign(ctx, target, ValueEnum::Dynamic(*val), *val_ty)?;
        }
    } else {
        assert_eq!(tuple_tys.len(), targets.len()); // The typechecker ensures this
        for (target, val, val_ty) in izip!(targets, tuple, tuple_tys) {
            generator.gen_assign(ctx, target, ValueEnum::Dynamic(val), *val_ty)?;
        }
    }
    Ok(())
 }
 /// See [`CodeGenerator::gen_setitem`].
 pub fn gen_setitem<'ctx, G: CodeGenerator>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    target: &Expr<Option<Type>>,
    key: &Expr<Option<Type>>,
    value: ValueEnum<'ctx>,
    value_ty: Type,
 ) -> Result<(), String> {
    let target_ty = target.custom.unwrap();
    let key_ty = key.custom.unwrap();
    match &*ctx.unifier.get_ty(target_ty) {
        TypeEnum::TObj { obj_id, params: list_params, .. }
            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
        {
            // Handle list item assignment
            let llvm_usize = generator.get_size_type(ctx.ctx);
            let target_item_ty = iter_type_vars(list_params).next().unwrap().ty;
            let target = generator
                .gen_expr(ctx, target)?
                .unwrap()
                .to_basic_value_enum(ctx, generator, target_ty)?
                .into_pointer_value();
            let target = ListValue::from_ptr_val(target, llvm_usize, None);
            if let ExprKind::Slice { .. } = &key.node {
                // Handle assigning to a slice
                let ExprKind::Slice { lower, upper, step } = &key.node else {
                    codegen_unreachable!(ctx)
                };
                let Some((start, end, step)) = handle_slice_indices(
                    lower,
                    upper,
                    step,
                    ctx,
                    generator,
                    target.load_size(ctx, None),
                )?
                else {
                    return Ok(());
                };
                let value =
                    value.to_basic_value_enum(ctx, generator, value_ty)?.into_pointer_value();
                let value = ListValue::from_ptr_val(value, llvm_usize, None);
                let target_item_ty = ctx.get_llvm_type(generator, target_item_ty);
                let Some(src_ind) = handle_slice_indices(
                    &None,
                    &None,
                    &None,
                    ctx,
                    generator,
                    value.load_size(ctx, None),
                )?
                else {
                    return Ok(());
                };
                list_slice_assignment(
                    generator,
                    ctx,
                    target_item_ty,
                    target,
                    (start, end, step),
                    value,
                    src_ind,
                );
            } else {
                // Handle assigning to an index
                let len = target.load_size(ctx, Some("len"));
                let index = generator
                    .gen_expr(ctx, key)?
                    .unwrap()
                    .to_basic_value_enum(ctx, generator, key_ty)?
                    .into_int_value();
                let index = ctx
                    .builder
                    .build_int_s_extend(index, generator.get_size_type(ctx.ctx), "sext")
                    .unwrap();
                // handle negative index
                let is_negative = ctx
                    .builder
                    .build_int_compare(
                        IntPredicate::SLT,
                        index,
                        generator.get_size_type(ctx.ctx).const_zero(),
                        "is_neg",
                    )
                    .unwrap();
                let adjusted = ctx.builder.build_int_add(index, len, "adjusted").unwrap();
                let index = ctx
                    .builder
                    .build_select(is_negative, adjusted, index, "index")
                    .map(BasicValueEnum::into_int_value)
                    .unwrap();
                // unsigned less than is enough, because negative index after adjustment is
                // bigger than the length (for unsigned cmp)
                let bound_check = ctx
                    .builder
                    .build_int_compare(IntPredicate::ULT, index, len, "inbound")
                    .unwrap();
                ctx.make_assert(
                    generator,
                    bound_check,
                    "0:IndexError",
                    "index {0} out of bounds 0:{1}",
                    [Some(index), Some(len), None],
                    key.location,
                );
                // Write value to index on list
                let item_ptr =
                    target.data().ptr_offset(ctx, generator, &index, Some("list_item_ptr"));
                let value = value.to_basic_value_enum(ctx, generator, value_ty)?;
                ctx.builder.build_store(item_ptr, value).unwrap();
            }
        }
        TypeEnum::TObj { obj_id, .. }
            if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
        {
            // Handle NDArray item assignment
            todo!("ndarray subscript assignment is not yet implemented");
        }
        _ => {
            panic!("encountered unknown target type: {}", ctx.unifier.stringify(target_ty));
        }
    }
    Ok(())
 }
 /// See [`CodeGenerator::gen_for`].
 pub fn gen_for<G: CodeGenerator>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::For { iter, target, body, orelse, .. } = &stmt.node else {
        codegen_unreachable!(ctx)
    };
    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -310,9 +442,6 @@ pub fn gen_for<G: CodeGenerator>(
    let orelse_bb =
        if orelse.is_empty() { cont_bb } else { ctx.ctx.append_basic_block(current, "for.orelse") };
    // Whether the iterable is a range() expression
    let is_iterable_range_expr = ctx.unifier.unioned(iter.custom.unwrap(), ctx.primitives.range);
    // The BB containing the increment expression
    let incr_bb = ctx.ctx.append_basic_block(current, "for.incr");
    // The BB containing the loop condition check
@ -321,27 +450,35 @@ pub fn gen_for<G: CodeGenerator>(
    // store loop bb information and restore it later
    let loop_bb = ctx.loop_target.replace((incr_bb, cont_bb));
    let iter_ty = iter.custom.unwrap();
    let iter_val = if let Some(v) = generator.gen_expr(ctx, iter)? {
-        v.to_basic_value_enum(ctx, generator, iter.custom.unwrap())?
+        v.to_basic_value_enum(ctx, generator, iter_ty)?
    } else {
        return Ok(());
    };
-    if is_iterable_range_expr {
+
    match &*ctx.unifier.get_ty(iter_ty) {
        TypeEnum::TObj { obj_id, .. }
            if *obj_id == ctx.primitives.range.obj_id(&ctx.unifier).unwrap() =>
        {
            let iter_val = RangeValue::from_ptr_val(iter_val.into_pointer_value(), Some("range"));
            // Internal variable for loop; Cannot be assigned
            let i = generator.gen_var_alloc(ctx, int32.into(), Some("for.i.addr"))?;
            // Variable declared in "target" expression of the loop; Can be reassigned *or* shadowed
-        let Some(target_i) = generator.gen_store_target(ctx, target, Some("for.target.addr"))?
+            let Some(target_i) =
                generator.gen_store_target(ctx, target, Some("for.target.addr"))?
            else {
-            unreachable!()
+                codegen_unreachable!(ctx)
            };
            let (start, stop, step) = destructure_range(ctx, iter_val);
            ctx.builder.build_store(i, start).unwrap();
            // Check "If step is zero, ValueError is raised."
-        let rangenez =
+            let rangenez = ctx
-            ctx.builder.build_int_compare(IntPredicate::NE, step, int32.const_zero(), "").unwrap();
+                .builder
                .build_int_compare(IntPredicate::NE, step, int32.const_zero(), "")
                .unwrap();
            ctx.make_assert(
                generator,
                rangenez,
@ -358,7 +495,10 @@ pub fn gen_for<G: CodeGenerator>(
                    .build_conditional_branch(
                        gen_in_range_check(
                            ctx,
-                        ctx.builder.build_load(i, "").map(BasicValueEnum::into_int_value).unwrap(),
+                            ctx.builder
                                .build_load(i, "")
                                .map(BasicValueEnum::into_int_value)
                                .unwrap(),
                            stop,
                            step,
                        ),
@ -388,7 +528,10 @@ pub fn gen_for<G: CodeGenerator>(
                )
                .unwrap();
            generator.gen_block(ctx, body.iter())?;
-    } else {
+        }
        TypeEnum::TObj { obj_id, params: list_params, .. }
            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
        {
            let index_addr = generator.gen_var_alloc(ctx, size_t.into(), Some("for.index.addr"))?;
            ctx.builder.build_store(index_addr, size_t.const_zero()).unwrap();
            let len = ctx
@ -426,9 +569,14 @@ pub fn gen_for<G: CodeGenerator>(
                .map(BasicValueEnum::into_int_value)
                .unwrap();
            let val = ctx.build_gep_and_load(arr_ptr, &[index], Some("val"));
-        generator.gen_assign(ctx, target, val.into())?;
+            let val_ty = iter_type_vars(list_params).next().unwrap().ty;
            generator.gen_assign(ctx, target, val.into(), val_ty)?;
            generator.gen_block(ctx, body.iter())?;
        }
        _ => {
            panic!("unsupported for loop iterator type: {}", ctx.unifier.stringify(iter_ty));
        }
    }
    for (k, (_, _, counter)) in &var_assignment {
        let (_, static_val, counter2) = ctx.var_assignment.get_mut(k).unwrap();
@ -462,12 +610,14 @@ pub fn gen_for<G: CodeGenerator>(
    Ok(())
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Hash)]
 pub struct BreakContinueHooks<'ctx> {
-    /// [`BasicBlock`] to branch to for `break`-ing out of the loop.
+    /// The [exit block][`BasicBlock`] to branch to when `break`-ing out of a loop.
-    pub break_bb: BasicBlock<'ctx>,
+    pub exit_bb: BasicBlock<'ctx>,
-    /// [`BasicBlock`] to branch to for `continue`-ing to the next iteration in the loop.
+
-    pub continue_bb: BasicBlock<'ctx>,
+    /// The [latch basic block][`BasicBlock`] to branch to for `continue`-ing to the next iteration
    /// of the loop.
    pub latch_bb: BasicBlock<'ctx>,
 }
 /// Generates a C-style `for` construct using lambdas, similar to the following C code:
@ -487,6 +637,7 @@ pub struct BreakContinueHooks<'ctx> {
 pub fn gen_for_callback<'ctx, 'a, G, I, InitFn, CondFn, BodyFn, UpdateFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
    label: Option<&str>,
    init: InitFn,
    cond: CondFn,
    body: BodyFn,
@ -497,18 +648,24 @@ where
    I: Clone,
    InitFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<I, String>,
    CondFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<IntValue<'ctx>, String>,
-    BodyFn:
+    BodyFn: FnOnce(
-        FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, BreakContinueHooks, I) -> Result<(), String>,
+        &mut G,
        &mut CodeGenContext<'ctx, 'a>,
        BreakContinueHooks<'ctx>,
        I,
    ) -> Result<(), String>,
    UpdateFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, I) -> Result<(), String>,
 {
    let label = label.unwrap_or("for");
    let current_bb = ctx.builder.get_insert_block().unwrap();
-    let init_bb = ctx.ctx.insert_basic_block_after(current_bb, "for.init");
+    let init_bb = ctx.ctx.insert_basic_block_after(current_bb, &format!("{label}.init"));
    // The BB containing the loop condition check
-    let cond_bb = ctx.ctx.insert_basic_block_after(init_bb, "for.cond");
+    let cond_bb = ctx.ctx.insert_basic_block_after(init_bb, &format!("{label}.cond"));
-    let body_bb = ctx.ctx.insert_basic_block_after(cond_bb, "for.body");
+    let body_bb = ctx.ctx.insert_basic_block_after(cond_bb, &format!("{label}.body"));
    // The BB containing the increment expression
-    let update_bb = ctx.ctx.insert_basic_block_after(body_bb, "for.update");
+    let update_bb = ctx.ctx.insert_basic_block_after(body_bb, &format!("{label}.update"));
-    let cont_bb = ctx.ctx.insert_basic_block_after(update_bb, "for.end");
+    let cont_bb = ctx.ctx.insert_basic_block_after(update_bb, &format!("{label}.end"));
    // store loop bb information and restore it later
    let loop_bb = ctx.loop_target.replace((update_bb, cont_bb));
@ -529,7 +686,7 @@ where
    }
    ctx.builder.position_at_end(body_bb);
-    let hooks = BreakContinueHooks { break_bb: cont_bb, continue_bb: update_bb };
+    let hooks = BreakContinueHooks { exit_bb: cont_bb, latch_bb: update_bb };
    body(generator, ctx, hooks, loop_var.clone())?;
    if !ctx.is_terminated() {
        ctx.builder.build_unconditional_branch(update_bb).unwrap();
@ -565,6 +722,7 @@ where
 pub fn gen_for_callback_incrementing<'ctx, 'a, G, BodyFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
    label: Option<&str>,
    init_val: IntValue<'ctx>,
    max_val: (IntValue<'ctx>, bool),
    body: BodyFn,
@ -575,7 +733,7 @@ where
    BodyFn: FnOnce(
        &mut G,
        &mut CodeGenContext<'ctx, 'a>,
-        BreakContinueHooks,
+        BreakContinueHooks<'ctx>,
        IntValue<'ctx>,
    ) -> Result<(), String>,
 {
@ -584,6 +742,7 @@ where
    gen_for_callback(
        generator,
        ctx,
        label,
        |generator, ctx| {
            let i_addr = generator.gen_var_alloc(ctx, init_val_t.into(), None)?;
            ctx.builder.build_store(i_addr, init_val).unwrap();
@ -635,9 +794,11 @@ where
 /// - `step_fn`: A lambda of IR statements that retrieves the `step` value of the  `range`-like
 ///   iterable. This value will be extended to the size of `start`.
 /// - `body_fn`: A lambda of IR statements within the loop body.
 #[allow(clippy::too_many_arguments)]
 pub fn gen_for_range_callback<'ctx, 'a, G, StartFn, StopFn, StepFn, BodyFn>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, 'a>,
    label: Option<&str>,
    is_unsigned: bool,
    start_fn: StartFn,
    (stop_fn, stop_inclusive): (StopFn, bool),
@ -649,13 +810,19 @@ where
    StartFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
    StopFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
    StepFn: Fn(&mut G, &mut CodeGenContext<'ctx, 'a>) -> Result<IntValue<'ctx>, String>,
-    BodyFn: FnOnce(&mut G, &mut CodeGenContext<'ctx, 'a>, IntValue<'ctx>) -> Result<(), String>,
+    BodyFn: FnOnce(
        &mut G,
        &mut CodeGenContext<'ctx, 'a>,
        BreakContinueHooks<'ctx>,
        IntValue<'ctx>,
    ) -> Result<(), String>,
 {
    let init_val_t = start_fn(generator, ctx).map(IntValue::get_type).unwrap();
    gen_for_callback(
        generator,
        ctx,
        label,
        |generator, ctx| {
            let i_addr = generator.gen_var_alloc(ctx, init_val_t.into(), None)?;
@ -713,10 +880,10 @@ where
            Ok(cond)
        },
-        |generator, ctx, _, (i_addr, _)| {
+        |generator, ctx, hooks, (i_addr, _)| {
            let i = ctx.builder.build_load(i_addr, "").map(BasicValueEnum::into_int_value).unwrap();
-            body_fn(generator, ctx, i)
+            body_fn(generator, ctx, hooks, i)
        },
        |generator, ctx, (i_addr, _)| {
            let i = ctx.builder.build_load(i_addr, "").map(BasicValueEnum::into_int_value).unwrap();
@ -744,7 +911,7 @@ pub fn gen_while<G: CodeGenerator>(
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::While { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };
    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -774,7 +941,7 @@ pub fn gen_while<G: CodeGenerator>(
        return Ok(());
    };
-    let BasicValueEnum::IntValue(test) = test else { unreachable!() };
+    let BasicValueEnum::IntValue(test) = test else { codegen_unreachable!(ctx) };
    ctx.builder
        .build_conditional_branch(generator.bool_to_i1(ctx, test), body_bb, orelse_bb)
@ -922,7 +1089,7 @@ pub fn gen_if<G: CodeGenerator>(
    ctx: &mut CodeGenContext<'_, '_>,
    stmt: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
-    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { unreachable!() };
+    let StmtKind::If { test, body, orelse, .. } = &stmt.node else { codegen_unreachable!(ctx) };
    // var_assignment static values may be changed in another branch
    // if so, remove the static value as it may not be correct in this branch
@ -1045,11 +1212,11 @@ pub fn exn_constructor<'ctx>(
    let zelf_id = if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(zelf_ty) {
        obj_id.0
    } else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    };
    let defs = ctx.top_level.definitions.read();
    let def = defs[zelf_id].read();
-    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { unreachable!() };
+    let TopLevelDef::Class { name: zelf_name, .. } = &*def else { codegen_unreachable!(ctx) };
    let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(zelf_id), zelf_name);
    unsafe {
        let id_ptr = ctx.builder.build_in_bounds_gep(zelf, &[zero, zero], "exn.id").unwrap();
@ -1157,7 +1324,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
    target: &Stmt<Option<Type>>,
 ) -> Result<(), String> {
    let StmtKind::Try { body, handlers, orelse, finalbody, .. } = &target.node else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    };
    // if we need to generate anything related to exception, we must have personality defined
@ -1234,7 +1401,7 @@ pub fn gen_try<'ctx, 'a, G: CodeGenerator>(
            if let TypeEnum::TObj { obj_id, .. } = &*ctx.unifier.get_ty(type_.custom.unwrap()) {
                *obj_id
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
        let exception_name = format!("{}:{}", ctx.resolver.get_exception_id(obj_id.0), exn_name);
        let exn_id = ctx.resolver.get_string_id(&exception_name);
@ -1506,6 +1673,23 @@ pub fn gen_return<G: CodeGenerator>(
    } else {
        None
    };
    // Remap boolean return type into i1
    let value = value.map(|ret_val| {
        // The "return type" of a sret function is in the first parameter
        let expected_ty = if ctx.need_sret {
            func.get_type().get_param_types()[0]
        } else {
            func.get_type().get_return_type().unwrap()
        };
        if matches!(expected_ty, BasicTypeEnum::IntType(ty) if ty.get_bit_width() == 1) {
            generator.bool_to_i1(ctx, ret_val.into_int_value()).into()
        } else {
            ret_val
        }
    });
    if let Some(return_target) = ctx.return_target {
        if let Some(value) = value {
            ctx.builder.build_store(ctx.return_buffer.unwrap(), value).unwrap();
@ -1516,25 +1700,6 @@ pub fn gen_return<G: CodeGenerator>(
        ctx.builder.build_store(ctx.return_buffer.unwrap(), value.unwrap()).unwrap();
        ctx.builder.build_return(None).unwrap();
    } else {
        // Remap boolean return type into i1
        let value = value.map(|v| {
            let expected_ty = func.get_type().get_return_type().unwrap();
            let ret_val = v.as_basic_value_enum();
            if expected_ty.is_int_type() && ret_val.is_int_value() {
                let ret_type = expected_ty.into_int_type();
                let ret_val = ret_val.into_int_value();
                if ret_type.get_bit_width() == 1 && ret_val.get_type().get_bit_width() != 1 {
                    generator.bool_to_i1(ctx, ret_val)
                } else {
                    ret_val
                }
                .into()
            } else {
                ret_val
            }
        });
        let value = value.as_ref().map(|v| v as &dyn BasicValue);
        ctx.builder.build_return(value).unwrap();
    }
@ -1568,14 +1733,14 @@ pub fn gen_stmt<G: CodeGenerator>(
        }
        StmtKind::AnnAssign { target, value, .. } => {
            if let Some(value) = value {
-                let Some(value) = generator.gen_expr(ctx, value)? else { return Ok(()) };
+                let Some(value_enum) = generator.gen_expr(ctx, value)? else { return Ok(()) };
-                generator.gen_assign(ctx, target, value)?;
+                generator.gen_assign(ctx, target, value_enum, value.custom.unwrap())?;
            }
        }
        StmtKind::Assign { targets, value, .. } => {
-            let Some(value) = generator.gen_expr(ctx, value)? else { return Ok(()) };
+            let Some(value_enum) = generator.gen_expr(ctx, value)? else { return Ok(()) };
            for target in targets {
-                generator.gen_assign(ctx, target, value.clone())?;
+                generator.gen_assign(ctx, target, value_enum.clone(), value.custom.unwrap())?;
            }
        }
        StmtKind::Continue { .. } => {
@ -1589,13 +1754,44 @@ pub fn gen_stmt<G: CodeGenerator>(
        StmtKind::For { .. } => generator.gen_for(ctx, stmt)?,
        StmtKind::With { .. } => generator.gen_with(ctx, stmt)?,
        StmtKind::AugAssign { target, op, value, .. } => {
-            let value = gen_binop_expr(generator, ctx, target, *op, value, stmt.location, true)?;
+            let value_enum = gen_binop_expr(
-            generator.gen_assign(ctx, target, value.unwrap())?;
+                generator,
                ctx,
                target,
                Binop::aug_assign(*op),
                value,
                stmt.location,
            )?
            .unwrap();
            generator.gen_assign(ctx, target, value_enum, value.custom.unwrap())?;
        }
        StmtKind::Try { .. } => gen_try(generator, ctx, stmt)?,
        StmtKind::Raise { exc, .. } => {
            if let Some(exc) = exc {
-                let exc = if let Some(v) = generator.gen_expr(ctx, exc)? {
+                let exn = if let ExprKind::Name { id, .. } = &exc.node {
                    // Handle "raise Exception" short form
                    let def_id = ctx.resolver.get_identifier_def(*id).map_err(|e| {
                        format!("{} (at {})", e.iter().next().unwrap(), exc.location)
                    })?;
                    let def = ctx.top_level.definitions.read();
                    let TopLevelDef::Class { constructor, .. } = *def[def_id.0].read() else {
                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
                    };
                    let TypeEnum::TFunc(signature) =
                        ctx.unifier.get_ty(constructor.unwrap()).as_ref().clone()
                    else {
                        return Err(format!("Failed to resolve symbol {id} (at {})", exc.location));
                    };
                    generator
                        .gen_call(ctx, None, (&signature, def_id), Vec::default())?
                        .map(Into::into)
                } else {
                    generator.gen_expr(ctx, exc)?
                };
                let exc = if let Some(v) = exn {
                    v.to_basic_value_enum(ctx, generator, exc.custom.unwrap())?
                } else {
                    return Ok(());
@ -1619,11 +1815,11 @@ pub fn gen_stmt<G: CodeGenerator>(
                        return Ok(());
                    }
                }
-                None => ctx.gen_string(generator, ""),
+                None => ctx.gen_string(generator, "").into(),
            };
            ctx.make_assert_impl(
                generator,
-                test.into_int_value(),
+                generator.bool_to_i1(ctx, test.into_int_value()),
                "0:AssertionError",
                err_msg,
                [None, None, None],
--- a/nac3core/src/codegen/test.rs
+++ b/nac3core/src/codegen/test.rs
@ -94,7 +94,7 @@ fn test_primitives() {
        "};
    let statements = parse_program(source, FileName::default()).unwrap();
-    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
@ -109,8 +109,18 @@ fn test_primitives() {
    let threads = vec![DefaultCodeGenerator::new("test".into(), 32).into()];
    let signature = FunSignature {
        args: vec![
-            FuncArg { name: "a".into(), ty: primitives.int32, default_value: None },
+            FuncArg {
-            FuncArg { name: "b".into(), ty: primitives.int32, default_value: None },
+                name: "a".into(),
                ty: primitives.int32,
                default_value: None,
                is_vararg: false,
            },
            FuncArg {
                name: "b".into(),
                ty: primitives.int32,
                default_value: None,
                is_vararg: false,
            },
        ],
        ret: primitives.int32,
        vars: VarMap::new(),
@ -189,6 +199,8 @@ fn test_primitives() {
        let expected = indoc! {"
            ; ModuleID = 'test'
            source_filename = \"test\"
            target datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128\"
            target triple = \"x86_64-unknown-linux-gnu\"
            ; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
            define i32 @testing(i32 %0, i32 %1) local_unnamed_addr #0 !dbg !4 {
@ -246,14 +258,19 @@ fn test_simple_call() {
        "};
    let statements_2 = parse_program(source_2, FileName::default()).unwrap();
-    let composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 32).0;
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
    unifier.top_level = Some(top_level.clone());
    let signature = FunSignature {
-        args: vec![FuncArg { name: "a".into(), ty: primitives.int32, default_value: None }],
+        args: vec![FuncArg {
            name: "a".into(),
            ty: primitives.int32,
            default_value: None,
            is_vararg: false,
        }],
        ret: primitives.int32,
        vars: VarMap::new(),
    };
@ -368,6 +385,8 @@ fn test_simple_call() {
        let expected = indoc! {"
            ; ModuleID = 'test'
            source_filename = \"test\"
            target datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128\"
            target triple = \"x86_64-unknown-linux-gnu\"
            ; Function Attrs: mustprogress nofree norecurse nosync nounwind readnone willreturn
            define i32 @testing(i32 %0) local_unnamed_addr #0 !dbg !5 {
--- a/nac3core/src/lib.rs
+++ b/nac3core/src/lib.rs
@ -19,6 +19,10 @@
    clippy::wildcard_imports
 )]
 // users of nac3core need to use the same version of these dependencies, so expose them as nac3core::*
 pub use inkwell;
 pub use nac3parser;
 pub mod codegen;
 pub mod symbol_resolver;
 pub mod toplevel;
--- a/nac3core/src/symbol_resolver.rs
+++ b/nac3core/src/symbol_resolver.rs
@ -78,14 +78,14 @@ impl SymbolValue {
            }
            Constant::Tuple(t) => {
                let expected_ty = unifier.get_ty(expected_ty);
-                let TypeEnum::TTuple { ty } = expected_ty.as_ref() else {
+                let TypeEnum::TTuple { ty, is_vararg_ctx } = expected_ty.as_ref() else {
                    return Err(format!(
                        "Expected {:?}, but got Tuple",
                        expected_ty.get_type_name()
                    ));
                };
-                assert_eq!(ty.len(), t.len());
+                assert!(*is_vararg_ctx || ty.len() == t.len());
                let elems = t
                    .iter()
@ -155,7 +155,7 @@ impl SymbolValue {
            SymbolValue::Bool(_) => primitives.bool,
            SymbolValue::Tuple(vs) => {
                let vs_tys = vs.iter().map(|v| v.get_type(primitives, unifier)).collect::<Vec<_>>();
-                unifier.add_ty(TypeEnum::TTuple { ty: vs_tys })
+                unifier.add_ty(TypeEnum::TTuple { ty: vs_tys, is_vararg_ctx: false })
            }
            SymbolValue::OptionSome(_) | SymbolValue::OptionNone => primitives.option,
        }
@ -382,13 +382,12 @@ pub trait SymbolResolver {
 }
 thread_local! {
-    static IDENTIFIER_ID: [StrRef; 12] = [
+    static IDENTIFIER_ID: [StrRef; 11] = [
        "int32".into(),
        "int64".into(),
        "float".into(),
        "bool".into(),
        "virtual".into(),
        "list".into(),
        "tuple".into(),
        "str".into(),
        "Exception".into(),
@ -413,13 +412,12 @@ pub fn parse_type_annotation<T>(
    let float_id = ids[2];
    let bool_id = ids[3];
    let virtual_id = ids[4];
-    let list_id = ids[5];
+    let tuple_id = ids[5];
-    let tuple_id = ids[6];
+    let str_id = ids[6];
-    let str_id = ids[7];
+    let exn_id = ids[7];
-    let exn_id = ids[8];
+    let uint32_id = ids[8];
-    let uint32_id = ids[9];
+    let uint64_id = ids[9];
-    let uint64_id = ids[10];
+    let literal_id = ids[10];
    let literal_id = ids[11];
    let name_handling = |id: &StrRef, loc: Location, unifier: &mut Unifier| {
        if *id == int32_id {
@ -476,9 +474,6 @@ pub fn parse_type_annotation<T>(
        if *id == virtual_id {
            let ty = parse_type_annotation(resolver, top_level_defs, unifier, primitives, slice)?;
            Ok(unifier.add_ty(TypeEnum::TVirtual { ty }))
        } else if *id == list_id {
            let ty = parse_type_annotation(resolver, top_level_defs, unifier, primitives, slice)?;
            Ok(unifier.add_ty(TypeEnum::TList { ty }))
        } else if *id == tuple_id {
            if let Tuple { elts, .. } = &slice.node {
                let ty = elts
@ -487,7 +482,7 @@ pub fn parse_type_annotation<T>(
                        parse_type_annotation(resolver, top_level_defs, unifier, primitives, elt)
                    })
                    .collect::<Result<Vec<_>, _>>()?;
-                Ok(unifier.add_ty(TypeEnum::TTuple { ty }))
+                Ok(unifier.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: false }))
            } else {
                Err(HashSet::from(["Expected multiple elements for tuple".into()]))
            }
--- a/nac3core/src/toplevel/builtins.rs
+++ b/nac3core/src/toplevel/builtins.rs
--- a/nac3core/src/toplevel/composer.rs
+++ b/nac3core/src/toplevel/composer.rs
@ -23,7 +23,7 @@ impl Default for ComposerConfig {
    }
 }
-type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
+pub type DefAst = (Arc<RwLock<TopLevelDef>>, Option<Stmt<()>>);
 pub struct TopLevelComposer {
    // list of top level definitions, same as top level context
    pub definition_ast_list: Vec<DefAst>,
@ -44,12 +44,27 @@ pub struct TopLevelComposer {
    pub size_t: u32,
 }
 /// The specification for a builtin function, consisting of the function name, the function
 /// signature, and a [code generation callback][`GenCall`].
 pub type BuiltinFuncSpec = (StrRef, FunSignature, Arc<GenCall>);
 /// A function that creates a [`BuiltinFuncSpec`] using the provided [`PrimitiveStore`] and
 /// [`Unifier`].
 pub type BuiltinFuncCreator = dyn Fn(&PrimitiveStore, &mut Unifier) -> BuiltinFuncSpec;
 impl TopLevelComposer {
    /// return a composer and things to make a "primitive" symbol resolver, so that the symbol
-    /// resolver can later figure out primitive type definitions when passed a primitive type name
+    /// resolver can later figure out primitive tye definitions when passed a primitive type name
    ///
    /// `lateinit_builtins` are specifically for the ARTIQ module. Since the [`Unifier`] instance
    /// used to create builtin functions do not persist until method compilation, any types
    /// created (e.g. [`TypeEnum::TVar`]) also do not persist. Those functions should be instead put
    /// in `lateinit_builtins`, where they will be instantiated with the [`Unifier`] instance used
    /// for method compilation.
    #[must_use]
    pub fn new(
-        builtins: Vec<(StrRef, FunSignature, Arc<GenCall>)>,
+        builtins: Vec<BuiltinFuncSpec>,
        lateinit_builtins: Vec<Box<BuiltinFuncCreator>>,
        core_config: ComposerConfig,
        size_t: u32,
    ) -> (Self, HashMap<StrRef, DefinitionId>, HashMap<StrRef, Type>) {
@ -119,7 +134,13 @@ impl TopLevelComposer {
            }
        }
-        for (name, sig, codegen_callback) in builtins {
+        // Materialize lateinit_builtins, now that the unifier is ready
        let lateinit_builtins = lateinit_builtins
            .into_iter()
            .map(|builtin| builtin(&primitives_ty, &mut unifier))
            .collect_vec();
        for (name, sig, codegen_callback) in builtins.into_iter().chain(lateinit_builtins) {
            let fun_sig = unifier.add_ty(TypeEnum::TFunc(sig));
            builtin_ty.insert(name, fun_sig);
            builtin_id.insert(name, DefinitionId(definition_ast_list.len()));
@ -766,6 +787,7 @@ impl TopLevelComposer {
            let target_ty = get_type_from_type_annotation_kinds(
                &temp_def_list,
                unifier,
                primitives,
                &def,
                &mut subst_list,
            )?;
@ -859,7 +881,73 @@ impl TopLevelComposer {
            let resolver = &**resolver;
            let mut function_var_map = VarMap::new();
-            let arg_types = {
+
            let vararg = args
                .vararg
                .as_ref()
                .map(|vararg| -> Result<_, HashSet<String>> {
                    let vararg = vararg.as_ref();
                    let annotation = vararg
                        .node
                        .annotation
                        .as_ref()
                        .ok_or_else(|| {
                            HashSet::from([format!(
                                "function parameter `{}` needs type annotation at {}",
                                vararg.node.arg, vararg.location
                            )])
                        })?
                        .as_ref();
                    let type_annotation = parse_ast_to_type_annotation_kinds(
                        resolver,
                        temp_def_list.as_slice(),
                        unifier,
                        primitives_store,
                        annotation,
                        // NOTE: since only class need this, for function
                        // it should be fine to be empty map
                        HashMap::new(),
                    )?;
                    let type_vars_within =
                        get_type_var_contained_in_type_annotation(&type_annotation)
                            .into_iter()
                            .map(|x| -> Result<TypeVar, HashSet<String>> {
                                let TypeAnnotation::TypeVar(ty) = x else {
                                    unreachable!("must be type var annotation kind")
                                };
                                let id = Self::get_var_id(ty, unifier)?;
                                Ok(TypeVar { id, ty })
                            })
                            .collect::<Result<Vec<_>, _>>()?;
                    for var in type_vars_within {
                        if let Some(prev_ty) = function_var_map.insert(var.id, var.ty) {
                            // if already have the type inserted, make sure they are the same thing
                            assert_eq!(prev_ty, var.ty);
                        }
                    }
                    let ty = get_type_from_type_annotation_kinds(
                        temp_def_list.as_ref(),
                        unifier,
                        primitives_store,
                        &type_annotation,
                        &mut None,
                    )?;
                    Ok(FuncArg {
                        name: vararg.node.arg,
                        ty,
                        default_value: Some(SymbolValue::Tuple(Vec::default())),
                        is_vararg: true,
                    })
                })
                .transpose()?;
            let mut arg_types = {
                // make sure no duplicate parameter
                let mut defined_parameter_name: HashSet<_> = HashSet::new();
                for x in &args.args {
@ -936,6 +1024,7 @@ impl TopLevelComposer {
                        let ty = get_type_from_type_annotation_kinds(
                            temp_def_list.as_ref(),
                            unifier,
                            primitives_store,
                            &type_annotation,
                            &mut None,
                        )?;
@ -959,11 +1048,18 @@ impl TopLevelComposer {
                                    v
                                }),
                            },
                            is_vararg: false,
                        })
                    })
                    .collect::<Result<Vec<_>, _>>()?
            };
            if let Some(vararg) = vararg {
                arg_types.push(vararg);
            };
            let arg_types = arg_types;
            let return_ty = {
                if let Some(returns) = returns {
                    let return_ty_annotation = {
@ -1002,6 +1098,7 @@ impl TopLevelComposer {
                    get_type_from_type_annotation_kinds(
                        &temp_def_list,
                        unifier,
                        primitives_store,
                        &return_ty_annotation,
                        &mut None,
                    )?
@ -1057,7 +1154,14 @@ impl TopLevelComposer {
        let (keyword_list, core_config) = core_info;
        let mut class_def = class_def.write();
        let TopLevelDef::Class {
-            object_id, ancestors, fields, methods, resolver, type_vars, ..
+            object_id,
            ancestors,
            fields,
            attributes,
            methods,
            resolver,
            type_vars,
            ..
        } = &mut *class_def
        else {
            unreachable!("here must be toplevel class def");
@ -1073,10 +1177,14 @@ impl TopLevelComposer {
            class_body_ast,
            _class_ancestor_def,
            class_fields_def,
            class_attributes_def,
            class_methods_def,
            class_type_vars_def,
            class_resolver,
-        ) = (*object_id, *name, bases, body, ancestors, fields, methods, type_vars, resolver);
+        ) = (
            *object_id, *name, bases, body, ancestors, fields, attributes, methods, type_vars,
            resolver,
        );
        let class_resolver = class_resolver.as_ref().unwrap();
        let class_resolver = class_resolver.as_ref();
@ -1203,6 +1311,7 @@ impl TopLevelComposer {
                                            })
                                        }
                                    },
                                    is_vararg: false,
                                };
                                // push the dummy type and the type annotation
                                // into the list for later unification
@ -1285,11 +1394,13 @@ impl TopLevelComposer {
                        .unify(method_dummy_ty, method_type)
                        .map_err(|e| HashSet::from([e.to_display(unifier).to_string()]))?;
                }
-                ast::StmtKind::AnnAssign { target, annotation, value: None, .. } => {
+                ast::StmtKind::AnnAssign { target, annotation, value, .. } => {
                    if let ast::ExprKind::Name { id: attr, .. } = &target.node {
                        if defined_fields.insert(attr.to_string()) {
                            let dummy_field_type = unifier.get_dummy_var().ty;
                            let annotation = match value {
                                None => {
                                    // handle Kernel[T], KernelInvariant[T]
                                    let (annotation, mutable) = match &annotation.node {
                                        ast::ExprKind::Subscript { value, slice, .. }
@ -1312,7 +1423,45 @@ impl TopLevelComposer {
                                        _ => continue, // ignore fields annotated otherwise
                                    };
                                    class_fields_def.push((*attr, dummy_field_type, mutable));
                                    annotation
                                }
                                // Supporting Class Attributes
                                Some(boxed_expr) => {
                                    // Class attributes are set as immutable regardless
                                    let (annotation, _) = match &annotation.node {
                                        ast::ExprKind::Subscript { slice, .. } => (slice, false),
                                        _ if core_config.kernel_ann.is_none() => (annotation, false),
                                        _ => continue,
                                    };
                                    match &**boxed_expr {
                                        ast::Located {location: _, custom: (), node: ast::ExprKind::Constant { value: v, kind: _ }} => {
                                            // Restricting the types allowed to be defined as class attributes
                                            match v {
                                                ast::Constant::Bool(_) | ast::Constant::Str(_) | ast::Constant::Int(_) | ast::Constant::Float(_) => {}
                                                _ => {
                                                        return Err(HashSet::from([
                                                        format!(
                                                            "unsupported statement in class definition body (at {})",
                                                            b.location
                                                        ),
                                                    ]))
                                                }
                                            }
                                            class_attributes_def.push((*attr, dummy_field_type, v.clone()));
                                        }
                                        _ => {
                                            return Err(HashSet::from([
                                                format!(
                                                    "unsupported statement in class definition body (at {})",
                                                    b.location
                                                ),
                                            ]))
                                        }
                                    }
                                    annotation
                                }
                            };
                            let parsed_annotation = parse_ast_to_type_annotation_kinds(
                                class_resolver,
                                temp_def_list,
@ -1384,7 +1533,14 @@ impl TopLevelComposer {
        type_var_to_concrete_def: &mut HashMap<Type, TypeAnnotation>,
    ) -> Result<(), HashSet<String>> {
        let TopLevelDef::Class {
-            object_id, ancestors, fields, methods, resolver, type_vars, ..
+            object_id,
            ancestors,
            fields,
            attributes,
            methods,
            resolver,
            type_vars,
            ..
        } = class_def
        else {
            unreachable!("here must be class def ast")
@ -1393,10 +1549,11 @@ impl TopLevelComposer {
            _class_id,
            class_ancestor_def,
            class_fields_def,
            class_attribute_def,
            class_methods_def,
            _class_type_vars_def,
            _class_resolver,
-        ) = (*object_id, ancestors, fields, methods, type_vars, resolver);
+        ) = (*object_id, ancestors, fields, attributes, methods, type_vars, resolver);
        // since when this function is called, the ancestors of the direct parent
        // are supposed to be already handled, so we only need to deal with the direct parent
@ -1407,7 +1564,7 @@ impl TopLevelComposer {
        let base = temp_def_list.get(id.0).unwrap();
        let base = base.read();
-        let TopLevelDef::Class { methods, fields, .. } = &*base else {
+        let TopLevelDef::Class { methods, fields, attributes, .. } = &*base else {
            unreachable!("must be top level class def")
        };
@ -1449,7 +1606,7 @@ impl TopLevelComposer {
            }
        }
        // use the new_child_methods to replace all the elements in `class_methods_def`
-        class_methods_def.drain(..);
+        class_methods_def.clear();
        class_methods_def.extend(new_child_methods);
        // handle class fields
@ -1459,7 +1616,9 @@ impl TopLevelComposer {
            let to_be_added = (*anc_field_name, *anc_field_ty, *mutable);
            // find if there is a fields with the same name in the child class
            for (class_field_name, ..) in &*class_fields_def {
-                if class_field_name == anc_field_name {
+                if class_field_name == anc_field_name
                    || attributes.iter().any(|f| f.0 == *class_field_name)
                {
                    return Err(HashSet::from([format!(
                        "field `{class_field_name}` has already declared in the ancestor classes"
                    )]));
@ -1467,14 +1626,33 @@ impl TopLevelComposer {
            }
            new_child_fields.push(to_be_added);
        }
        // handle class attributes
        let mut new_child_attributes: Vec<(StrRef, Type, ast::Constant)> = Vec::new();
        for (anc_attr_name, anc_attr_ty, attr_value) in attributes {
            let to_be_added = (*anc_attr_name, *anc_attr_ty, attr_value.clone());
            // find if there is a attribute with the same name in the child class
            for (class_attr_name, ..) in &*class_attribute_def {
                if class_attr_name == anc_attr_name
                    || fields.iter().any(|f| f.0 == *class_attr_name)
                {
                    return Err(HashSet::from([format!(
                        "attribute `{class_attr_name}` has already declared in the ancestor classes"
                    )]));
                }
            }
            new_child_attributes.push(to_be_added);
        }
        for (class_field_name, class_field_ty, mutable) in &*class_fields_def {
            if !is_override.contains(class_field_name) {
                new_child_fields.push((*class_field_name, *class_field_ty, *mutable));
            }
        }
-        class_fields_def.drain(..);
+        class_fields_def.clear();
        class_fields_def.extend(new_child_fields);
-
+        class_attribute_def.clear();
        class_attribute_def.extend(new_child_attributes);
        Ok(())
    }
@ -1542,6 +1720,7 @@ impl TopLevelComposer {
                let self_type = get_type_from_type_annotation_kinds(
                    &def_list,
                    unifier,
                    primitives_ty,
                    &make_self_type_annotation(type_vars, *object_id),
                    &mut None,
                )?;
@ -1558,21 +1737,25 @@ impl TopLevelComposer {
                                name: "msg".into(),
                                ty: string,
                                default_value: Some(SymbolValue::Str(String::new())),
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param0".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param1".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "param2".into(),
                                ty: int64,
                                default_value: Some(SymbolValue::I64(0)),
                                is_vararg: false,
                            },
                        ],
                        ret: self_type,
@ -1639,7 +1822,12 @@ impl TopLevelComposer {
                        if *name != init_str_id {
                            unreachable!("must be init function here")
                        }
-                        let all_inited = Self::get_all_assigned_field(body.as_slice())?;
+
                        let all_inited = Self::get_all_assigned_field(
                            object_id.0,
                            definition_ast_list,
                            body.as_slice(),
                        )?;
                        for (f, _, _) in fields {
                            if !all_inited.contains(f) {
                                return Err(HashSet::from([
@ -1706,7 +1894,8 @@ impl TopLevelComposer {
            } = &mut *function_def
            {
                let signature_ty_enum = unifier.get_ty(*signature);
-                let TypeEnum::TFunc(FunSignature { args, ret, vars }) = signature_ty_enum.as_ref()
+                let TypeEnum::TFunc(FunSignature { args, ret, vars, .. }) =
                    signature_ty_enum.as_ref()
                else {
                    unreachable!("must be typeenum::tfunc")
                };
@ -1723,7 +1912,11 @@ impl TopLevelComposer {
                        let ty_ann = make_self_type_annotation(type_vars, *class_id);
                        let self_ty = get_type_from_type_annotation_kinds(
-                            &def_list, unifier, &ty_ann, &mut None,
+                            &def_list,
                            unifier,
                            primitives_ty,
                            &ty_ann,
                            &mut None,
                        )?;
                        vars.extend(type_vars.iter().map(|ty| {
                            let TypeEnum::TVar { id, .. } = &*unifier.get_ty(*ty) else {
@ -1778,6 +1971,7 @@ impl TopLevelComposer {
                                name: a.name,
                                ty: unifier.subst(a.ty, &subst).unwrap_or(a.ty),
                                default_value: a.default_value.clone(),
                                is_vararg: false,
                            })
                            .collect_vec()
                    };
@ -1864,6 +2058,16 @@ impl TopLevelComposer {
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }
                    if !decorator_list.is_empty() {
                        if let ast::ExprKind::Call { func, .. } = &decorator_list[0].node {
                            if matches!(&func.node,
                                ast::ExprKind::Name{ id, .. } if id == &"rpc".into())
                            {
                                instance_to_symbol.insert(String::new(), simple_name.to_string());
                                continue;
                            }
                        }
                    }
                    let fun_body = body
                        .into_iter()
--- a/nac3core/src/toplevel/helper.rs
+++ b/nac3core/src/toplevel/helper.rs
@ -2,7 +2,8 @@ use std::convert::TryInto;
 use crate::symbol_resolver::SymbolValue;
 use crate::toplevel::numpy::unpack_ndarray_var_tys;
-use crate::typecheck::typedef::{into_var_map, Mapping, TypeVarId, VarMap};
+use crate::typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap};
 use ast::ExprKind;
 use nac3parser::ast::{Constant, Location};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
@ -12,6 +13,7 @@ use super::*;
 /// All primitive types and functions in nac3core.
 #[derive(Clone, Copy, Debug, EnumIter, PartialEq, Eq)]
 pub enum PrimDef {
    // Classes
    Int32,
    Int64,
    Float,
@ -23,17 +25,25 @@ pub enum PrimDef {
    UInt32,
    UInt64,
    Option,
-    OptionIsSome,
+    List,
    OptionIsNone,
    OptionUnwrap,
    NDArray,
-    NDArrayCopy,
+
-    NDArrayFill,
+    // Option methods
-    FunInt32,
+    FunOptionIsSome,
-    FunInt64,
+    FunOptionIsNone,
-    FunUInt32,
+    FunOptionUnwrap,
-    FunUInt64,
+
-    FunFloat,
+    // Option-related functions
    FunSome,
    // NDArray methods
    FunNDArrayCopy,
    FunNDArrayFill,
    // Range methods
    FunRangeInit,
    // NumPy factory functions
    FunNpNDArray,
    FunNpEmpty,
    FunNpZeros,
@ -42,26 +52,17 @@ pub enum PrimDef {
    FunNpArray,
    FunNpEye,
    FunNpIdentity,
-    FunRound,
+
-    FunRound64,
+    // Miscellaneous NumPy & SciPy functions
    FunNpRound,
    FunRange,
    FunStr,
    FunBool,
    FunFloor,
    FunFloor64,
    FunNpFloor,
    FunCeil,
    FunCeil64,
    FunNpCeil,
    FunLen,
    FunMin,
    FunNpMin,
    FunNpMinimum,
-    FunMax,
+    FunNpArgmin,
    FunNpMax,
    FunNpMaximum,
-    FunAbs,
+    FunNpArgmax,
    FunNpIsNan,
    FunNpIsInf,
    FunNpSin,
@ -99,15 +100,46 @@ pub enum PrimDef {
    FunNpLdExp,
    FunNpHypot,
    FunNpNextAfter,
-    FunSome,
+    FunNpTranspose,
-    FunNpAny,
+    FunNpReshape,
-    FunNpAll,
+
    // Linalg functions
    FunNpDot,
    FunNpLinalgCholesky,
    FunNpLinalgQr,
    FunNpLinalgSvd,
    FunNpLinalgInv,
    FunNpLinalgPinv,
    FunNpLinalgMatrixPower,
    FunNpLinalgDet,
    FunSpLinalgLu,
    FunSpLinalgSchur,
    FunSpLinalgHessenberg,
    // Miscellaneous Python & NAC3 functions
    FunInt32,
    FunInt64,
    FunUInt32,
    FunUInt64,
    FunFloat,
    FunRound,
    FunRound64,
    FunStr,
    FunBool,
    FunFloor,
    FunFloor64,
    FunCeil,
    FunCeil64,
    FunLen,
    FunMin,
    FunMax,
    FunAbs,
 }
 /// Associated details of a [`PrimDef`]
 pub enum PrimDefDetails {
    PrimFunction { name: &'static str, simple_name: &'static str },
-    PrimClass { name: &'static str },
+    PrimClass { name: &'static str, get_ty_fn: fn(&PrimitiveStore) -> Type },
 }
 impl PrimDef {
@ -149,15 +181,17 @@ impl PrimDef {
    #[must_use]
    pub fn name(&self) -> &'static str {
        match self.details() {
-            PrimDefDetails::PrimFunction { name, .. } | PrimDefDetails::PrimClass { name } => name,
+            PrimDefDetails::PrimFunction { name, .. } | PrimDefDetails::PrimClass { name, .. } => {
                name
            }
        }
    }
    /// Get the associated details of this [`PrimDef`]
    #[must_use]
    pub fn details(self) -> PrimDefDetails {
-        fn class(name: &'static str) -> PrimDefDetails {
+        fn class(name: &'static str, get_ty_fn: fn(&PrimitiveStore) -> Type) -> PrimDefDetails {
-            PrimDefDetails::PrimClass { name }
+            PrimDefDetails::PrimClass { name, get_ty_fn }
        }
        fn fun(name: &'static str, simple_name: Option<&'static str>) -> PrimDefDetails {
@ -165,28 +199,37 @@ impl PrimDef {
        }
        match self {
-            PrimDef::Int32 => class("int32"),
+            // Classes
-            PrimDef::Int64 => class("int64"),
+            PrimDef::Int32 => class("int32", |primitives| primitives.int32),
-            PrimDef::Float => class("float"),
+            PrimDef::Int64 => class("int64", |primitives| primitives.int64),
-            PrimDef::Bool => class("bool"),
+            PrimDef::Float => class("float", |primitives| primitives.float),
-            PrimDef::None => class("none"),
+            PrimDef::Bool => class("bool", |primitives| primitives.bool),
-            PrimDef::Range => class("range"),
+            PrimDef::None => class("none", |primitives| primitives.none),
-            PrimDef::Str => class("str"),
+            PrimDef::Range => class("range", |primitives| primitives.range),
-            PrimDef::Exception => class("Exception"),
+            PrimDef::Str => class("str", |primitives| primitives.str),
-            PrimDef::UInt32 => class("uint32"),
+            PrimDef::Exception => class("Exception", |primitives| primitives.exception),
-            PrimDef::UInt64 => class("uint64"),
+            PrimDef::UInt32 => class("uint32", |primitives| primitives.uint32),
-            PrimDef::Option => class("Option"),
+            PrimDef::UInt64 => class("uint64", |primitives| primitives.uint64),
-            PrimDef::OptionIsSome => fun("Option.is_some", Some("is_some")),
+            PrimDef::Option => class("Option", |primitives| primitives.option),
-            PrimDef::OptionIsNone => fun("Option.is_none", Some("is_none")),
+            PrimDef::List => class("list", |primitives| primitives.list),
-            PrimDef::OptionUnwrap => fun("Option.unwrap", Some("unwrap")),
+            PrimDef::NDArray => class("ndarray", |primitives| primitives.ndarray),
-            PrimDef::NDArray => class("ndarray"),
+
-            PrimDef::NDArrayCopy => fun("ndarray.copy", Some("copy")),
+            // Option methods
-            PrimDef::NDArrayFill => fun("ndarray.fill", Some("fill")),
+            PrimDef::FunOptionIsSome => fun("Option.is_some", Some("is_some")),
-            PrimDef::FunInt32 => fun("int32", None),
+            PrimDef::FunOptionIsNone => fun("Option.is_none", Some("is_none")),
-            PrimDef::FunInt64 => fun("int64", None),
+            PrimDef::FunOptionUnwrap => fun("Option.unwrap", Some("unwrap")),
-            PrimDef::FunUInt32 => fun("uint32", None),
+
-            PrimDef::FunUInt64 => fun("uint64", None),
+            // Option-related functions
-            PrimDef::FunFloat => fun("float", None),
+            PrimDef::FunSome => fun("Some", None),
            // NDArray methods
            PrimDef::FunNDArrayCopy => fun("ndarray.copy", Some("copy")),
            PrimDef::FunNDArrayFill => fun("ndarray.fill", Some("fill")),
            // Range methods
            PrimDef::FunRangeInit => fun("range.__init__", Some("__init__")),
            // NumPy factory functions
            PrimDef::FunNpNDArray => fun("np_ndarray", None),
            PrimDef::FunNpEmpty => fun("np_empty", None),
            PrimDef::FunNpZeros => fun("np_zeros", None),
@ -195,26 +238,17 @@ impl PrimDef {
            PrimDef::FunNpArray => fun("np_array", None),
            PrimDef::FunNpEye => fun("np_eye", None),
            PrimDef::FunNpIdentity => fun("np_identity", None),
-            PrimDef::FunRound => fun("round", None),
+
-            PrimDef::FunRound64 => fun("round64", None),
+            // Miscellaneous NumPy & SciPy functions
            PrimDef::FunNpRound => fun("np_round", None),
            PrimDef::FunRange => fun("range", None),
            PrimDef::FunStr => fun("str", None),
            PrimDef::FunBool => fun("bool", None),
            PrimDef::FunFloor => fun("floor", None),
            PrimDef::FunFloor64 => fun("floor64", None),
            PrimDef::FunNpFloor => fun("np_floor", None),
            PrimDef::FunCeil => fun("ceil", None),
            PrimDef::FunCeil64 => fun("ceil64", None),
            PrimDef::FunNpCeil => fun("np_ceil", None),
            PrimDef::FunLen => fun("len", None),
            PrimDef::FunMin => fun("min", None),
            PrimDef::FunNpMin => fun("np_min", None),
            PrimDef::FunNpMinimum => fun("np_minimum", None),
-            PrimDef::FunMax => fun("max", None),
+            PrimDef::FunNpArgmin => fun("np_argmin", None),
            PrimDef::FunNpMax => fun("np_max", None),
            PrimDef::FunNpMaximum => fun("np_maximum", None),
-            PrimDef::FunAbs => fun("abs", None),
+            PrimDef::FunNpArgmax => fun("np_argmax", None),
            PrimDef::FunNpIsNan => fun("np_isnan", None),
            PrimDef::FunNpIsInf => fun("np_isinf", None),
            PrimDef::FunNpSin => fun("np_sin", None),
@ -252,9 +286,40 @@ impl PrimDef {
            PrimDef::FunNpLdExp => fun("np_ldexp", None),
            PrimDef::FunNpHypot => fun("np_hypot", None),
            PrimDef::FunNpNextAfter => fun("np_nextafter", None),
-            PrimDef::FunSome => fun("Some", None),
+            PrimDef::FunNpTranspose => fun("np_transpose", None),
-            PrimDef::FunNpAny => fun("np_any", None),
+            PrimDef::FunNpReshape => fun("np_reshape", None),
-            PrimDef::FunNpAll => fun("np_all", None),
+
            // Linalg functions
            PrimDef::FunNpDot => fun("np_dot", None),
            PrimDef::FunNpLinalgCholesky => fun("np_linalg_cholesky", None),
            PrimDef::FunNpLinalgQr => fun("np_linalg_qr", None),
            PrimDef::FunNpLinalgSvd => fun("np_linalg_svd", None),
            PrimDef::FunNpLinalgInv => fun("np_linalg_inv", None),
            PrimDef::FunNpLinalgPinv => fun("np_linalg_pinv", None),
            PrimDef::FunNpLinalgMatrixPower => fun("np_linalg_matrix_power", None),
            PrimDef::FunNpLinalgDet => fun("np_linalg_det", None),
            PrimDef::FunSpLinalgLu => fun("sp_linalg_lu", None),
            PrimDef::FunSpLinalgSchur => fun("sp_linalg_schur", None),
            PrimDef::FunSpLinalgHessenberg => fun("sp_linalg_hessenberg", None),
            // Miscellaneous Python & NAC3 functions
            PrimDef::FunInt32 => fun("int32", None),
            PrimDef::FunInt64 => fun("int64", None),
            PrimDef::FunUInt32 => fun("uint32", None),
            PrimDef::FunUInt64 => fun("uint64", None),
            PrimDef::FunFloat => fun("float", None),
            PrimDef::FunRound => fun("round", None),
            PrimDef::FunRound64 => fun("round64", None),
            PrimDef::FunStr => fun("str", None),
            PrimDef::FunBool => fun("bool", None),
            PrimDef::FunFloor => fun("floor", None),
            PrimDef::FunFloor64 => fun("floor64", None),
            PrimDef::FunCeil => fun("ceil", None),
            PrimDef::FunCeil64 => fun("ceil64", None),
            PrimDef::FunLen => fun("len", None),
            PrimDef::FunMin => fun("min", None),
            PrimDef::FunMax => fun("max", None),
            PrimDef::FunAbs => fun("abs", None),
        }
    }
 }
@ -358,7 +423,13 @@ impl TopLevelComposer {
        });
        let range = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::Range.id(),
-            fields: HashMap::new(),
+            fields: [
                ("start".into(), (int32, true)),
                ("stop".into(), (int32, true)),
                ("step".into(), (int32, true)),
            ]
            .into_iter()
            .collect(),
            params: VarMap::new(),
        });
        let str = unifier.add_ty(TypeEnum::TObj {
@ -399,9 +470,9 @@ impl TopLevelComposer {
        let option = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::Option.id(),
            fields: vec![
-                (PrimDef::OptionIsSome.simple_name().into(), (is_some_type_fun_ty, true)),
+                (PrimDef::FunOptionIsSome.simple_name().into(), (is_some_type_fun_ty, true)),
-                (PrimDef::OptionIsNone.simple_name().into(), (is_some_type_fun_ty, true)),
+                (PrimDef::FunOptionIsNone.simple_name().into(), (is_some_type_fun_ty, true)),
-                (PrimDef::OptionUnwrap.simple_name().into(), (unwrap_fun_ty, true)),
+                (PrimDef::FunOptionUnwrap.simple_name().into(), (unwrap_fun_ty, true)),
            ]
            .into_iter()
            .collect::<HashMap<_, _>>(),
@ -414,6 +485,13 @@ impl TopLevelComposer {
            _ => unreachable!(),
        };
        let list_elem_tvar = unifier.get_fresh_var(Some("list_elem".into()), None);
        let list = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::List.id(),
            fields: Mapping::new(),
            params: into_var_map([list_elem_tvar]),
        });
        let ndarray_dtype_tvar = unifier.get_fresh_var(Some("ndarray_dtype".into()), None);
        let ndarray_ndims_tvar =
            unifier.get_fresh_const_generic_var(size_t_ty, Some("ndarray_ndims".into()), None);
@ -428,6 +506,7 @@ impl TopLevelComposer {
                name: "value".into(),
                ty: ndarray_dtype_tvar.ty,
                default_value: None,
                is_vararg: false,
            }],
            ret: none,
            vars: into_var_map([ndarray_dtype_tvar, ndarray_ndims_tvar]),
@ -435,8 +514,8 @@ impl TopLevelComposer {
        let ndarray = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::NDArray.id(),
            fields: Mapping::from([
-                (PrimDef::NDArrayCopy.simple_name().into(), (ndarray_copy_fun_ty, true)),
+                (PrimDef::FunNDArrayCopy.simple_name().into(), (ndarray_copy_fun_ty, true)),
-                (PrimDef::NDArrayFill.simple_name().into(), (ndarray_fill_fun_ty, true)),
+                (PrimDef::FunNDArrayFill.simple_name().into(), (ndarray_fill_fun_ty, true)),
            ]),
            params: into_var_map([ndarray_dtype_tvar, ndarray_ndims_tvar]),
        });
@ -455,6 +534,7 @@ impl TopLevelComposer {
            str,
            exception,
            option,
            list,
            ndarray,
            size_t,
        };
@ -478,6 +558,7 @@ impl TopLevelComposer {
            object_id: obj_id,
            type_vars: Vec::default(),
            fields: Vec::default(),
            attributes: Vec::default(),
            methods: Vec::default(),
            ancestors: Vec::default(),
            constructor,
@ -653,7 +734,16 @@ impl TopLevelComposer {
        )
    }
-    pub fn get_all_assigned_field(stmts: &[Stmt<()>]) -> Result<HashSet<StrRef>, HashSet<String>> {
+    /// This function returns the fields that have been initialized in the `__init__` function of a class
    /// The function takes as input:
    ///  * `class_id`: The `object_id` of the class whose function is being evaluated (check `TopLevelDef::Class`)
    ///  * `definition_ast_list`: A list of ast definitions and statements defined in `TopLevelComposer`
    ///  * `stmts`: The body of function being parsed. Each statment is analyzed to check varaible initialization statements
    pub fn get_all_assigned_field(
        class_id: usize,
        definition_ast_list: &Vec<DefAst>,
        stmts: &[Stmt<()>],
    ) -> Result<HashSet<StrRef>, HashSet<String>> {
        let mut result = HashSet::new();
        for s in stmts {
            match &s.node {
@ -689,30 +779,138 @@ impl TopLevelComposer {
                // TODO: do not check for For and While?
                ast::StmtKind::For { body, orelse, .. }
                | ast::StmtKind::While { body, orelse, .. } => {
-                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
-                    result.extend(Self::get_all_assigned_field(orelse.as_slice())?);
+                        class_id,
                        definition_ast_list,
                        body.as_slice(),
                    )?);
                    result.extend(Self::get_all_assigned_field(
                        class_id,
                        definition_ast_list,
                        orelse.as_slice(),
                    )?);
                }
                ast::StmtKind::If { body, orelse, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
+                    let inited_for_sure = Self::get_all_assigned_field(
-                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                        class_id,
                        definition_ast_list,
                        body.as_slice(),
                    )?
                    .intersection(&Self::get_all_assigned_field(
                        class_id,
                        definition_ast_list,
                        orelse.as_slice(),
                    )?)
                    .copied()
                    .collect::<HashSet<_>>();
                    result.extend(inited_for_sure);
                }
                ast::StmtKind::Try { body, orelse, finalbody, .. } => {
-                    let inited_for_sure = Self::get_all_assigned_field(body.as_slice())?
+                    let inited_for_sure = Self::get_all_assigned_field(
-                        .intersection(&Self::get_all_assigned_field(orelse.as_slice())?)
+                        class_id,
                        definition_ast_list,
                        body.as_slice(),
                    )?
                    .intersection(&Self::get_all_assigned_field(
                        class_id,
                        definition_ast_list,
                        orelse.as_slice(),
                    )?)
                    .copied()
                    .collect::<HashSet<_>>();
                    result.extend(inited_for_sure);
-                    result.extend(Self::get_all_assigned_field(finalbody.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
                        class_id,
                        definition_ast_list,
                        finalbody.as_slice(),
                    )?);
                }
                ast::StmtKind::With { body, .. } => {
-                    result.extend(Self::get_all_assigned_field(body.as_slice())?);
+                    result.extend(Self::get_all_assigned_field(
                        class_id,
                        definition_ast_list,
                        body.as_slice(),
                    )?);
                }
                // Variables Initialized in function calls
                ast::StmtKind::Expr { value, .. } => {
                    let ExprKind::Call { func, .. } = &value.node else {
                        continue;
                    };
                    let ExprKind::Attribute { value, attr, .. } = &func.node else {
                        continue;
                    };
                    let ExprKind::Name { id, .. } = &value.node else {
                        continue;
                    };
                    // Need to consider the two cases:
                    //  Case 1) Call to class function i.e. id = `self`
                    //  Case 2) Call to class ancestor function i.e. id = ancestor_name
                    // We leave checking whether function in case 2 belonged to class ancestor or not to type checker
                    //
                    // According to current handling of `self`, function definition are fixed and do not change regardless
                    // of which object is passed as `self` i.e. virtual polymorphism is not supported
                    // Therefore, we change class id for case 2 to reflect behavior of our compiler
                    let class_name = if *id == "self".into() {
                        let ast::StmtKind::ClassDef { name, .. } =
                            &definition_ast_list[class_id].1.as_ref().unwrap().node
                        else {
                            unreachable!()
                        };
                        name
                    } else {
                        id
                    };
                    let parent_method = definition_ast_list.iter().find_map(|def| {
                        let (
                            class_def,
                            Some(ast::Located {
                                node: ast::StmtKind::ClassDef { name, body, .. },
                                ..
                            }),
                        ) = &def
                        else {
                            return None;
                        };
                        let TopLevelDef::Class { object_id: class_id, .. } = &*class_def.read()
                        else {
                            unreachable!()
                        };
                        if name == class_name {
                            body.iter().find_map(|m| {
                                let ast::StmtKind::FunctionDef { name, body, .. } = &m.node else {
                                    return None;
                                };
                                if *name == *attr {
                                    return Some((body.clone(), class_id.0));
                                }
                                None
                            })
                        } else {
                            None
                        }
                    });
                    // If method body is none then method does not exist
                    if let Some((method_body, class_id)) = parent_method {
                        result.extend(Self::get_all_assigned_field(
                            class_id,
                            definition_ast_list,
                            method_body.as_slice(),
                        )?);
                    } else {
                        return Err(HashSet::from([format!(
                            "{}.{} not found in class {class_name} at {}",
                            *id, *attr, value.location
                        )]));
                    }
                }
                ast::StmtKind::Pass { .. }
                | ast::StmtKind::Assert { .. }
-                | ast::StmtKind::Expr { .. } => {}
+                | ast::StmtKind::AnnAssign { .. } => {}
                _ => {
                    unimplemented!()
@ -891,7 +1089,9 @@ pub fn arraylike_flatten_element_type(unifier: &mut Unifier, ty: Type) -> Type {
            unpack_ndarray_var_tys(unifier, ty).0
        }
-        TypeEnum::TList { ty } => arraylike_flatten_element_type(unifier, *ty),
+        TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
            arraylike_flatten_element_type(unifier, iter_type_vars(params).next().unwrap().ty)
        }
        _ => ty,
    }
 }
@ -912,7 +1112,9 @@ pub fn arraylike_get_ndims(unifier: &mut Unifier, ty: Type) -> u64 {
            u64::try_from(values[0].clone()).unwrap()
        }
-        TypeEnum::TList { ty } => arraylike_get_ndims(unifier, *ty) + 1,
+        TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
            arraylike_get_ndims(unifier, iter_type_vars(params).next().unwrap().ty) + 1
        }
        _ => 0,
    }
 }
--- a/nac3core/src/toplevel/mod.rs
+++ b/nac3core/src/toplevel/mod.rs
@ -103,6 +103,10 @@ pub enum TopLevelDef {
        ///
        /// Name and type is mutable.
        fields: Vec<(StrRef, Type, bool)>,
        /// Class Attributes.
        ///
        /// Name, type, value.
        attributes: Vec<(StrRef, Type, ast::Constant)>,
        /// Class methods, pointing to the corresponding function definition.
        methods: Vec<(StrRef, Type, DefinitionId)>,
        /// Ancestor classes, including itself.
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
@ -5,7 +5,7 @@ expression: res_vec
 [
    "Class {\nname: \"Generic_A\",\nancestors: [\"Generic_A[V]\", \"B\"],\nfields: [\"aa\", \"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\"), (\"fun\", \"fn[[a:int32], V]\")],\ntype_vars: [\"V\"]\n}\n",
    "Function {\nname: \"Generic_A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(239)]\n}\n",
+    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(241)]\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [\"aa\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.foo\",\nsig: \"fn[[b:T], none]\",\nvar_id: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
@ -7,7 +7,7 @@ expression: res_vec
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[t:T], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.foo\",\nsig: \"fn[[c:C], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B[typevar228]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar228\"]\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B[typevar230]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar230\"]\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"C\",\nancestors: [\"C\", \"B[bool]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\", \"e\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
@ -5,8 +5,8 @@ expression: res_vec
 [
    "Function {\nname: \"foo\",\nsig: \"fn[[a:list[int32], b:tuple[T, float]], A[B, bool]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"A\",\nancestors: [\"A[T, V]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[v:V], none]\"), (\"fun\", \"fn[[a:T], V]\")],\ntype_vars: [\"T\", \"V\"]\n}\n",
-    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(241)]\n}\n",
+    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(243)]\n}\n",
-    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(246)]\n}\n",
+    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(248)]\n}\n",
    "Function {\nname: \"gfun\",\nsig: \"fn[[a:A[list[float], int32]], none]\",\nvar_id: []\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [],\nmethods: [(\"__init__\", \"fn[[], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
@ -3,7 +3,7 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A[typevar227, typevar228]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar227\", \"typevar228\"]\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[typevar229, typevar230]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar229\", \"typevar230\"]\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[a:A[float, bool], b:B], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:A[float, bool]], A[bool, int32]]\",\nvar_id: []\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\")],\ntype_vars: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
@ -6,12 +6,12 @@ expression: res_vec
    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(247)]\n}\n",
+    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(249)]\n}\n",
    "Class {\nname: \"B\",\nancestors: [\"B\", \"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Class {\nname: \"C\",\nancestors: [\"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"C.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"C.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"foo\",\nsig: \"fn[[a:A], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(255)]\n}\n",
+    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(257)]\n}\n",
 ]
--- a/nac3core/src/toplevel/test.rs
+++ b/nac3core/src/toplevel/test.rs
@ -1,3 +1,6 @@
 use super::*;
 use crate::toplevel::helper::PrimDef;
 use crate::typecheck::typedef::into_var_map;
 use crate::{
    codegen::CodeGenContext,
    symbol_resolver::{SymbolResolver, ValueEnum},
@ -14,8 +17,6 @@ use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
 use test_case::test_case;
 use super::*;
 struct ResolverInternal {
    id_to_type: Mutex<HashMap<StrRef, Type>>,
    id_to_def: Mutex<HashMap<StrRef, DefinitionId>>,
@ -116,7 +117,8 @@ impl SymbolResolver for Resolver {
    "register"
 )]
 fn test_simple_register(source: Vec<&str>) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    for s in source {
        let ast = parse_program(s, FileName::default()).unwrap();
@ -136,7 +138,8 @@ fn test_simple_register(source: Vec<&str>) {
    "register"
 )]
 fn test_simple_register_without_constructor(source: &str) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let ast = parse_program(source, FileName::default()).unwrap();
    let ast = ast[0].clone();
    composer.register_top_level(ast, None, "", true).unwrap();
@ -170,7 +173,8 @@ fn test_simple_register_without_constructor(source: &str) {
    "function compose"
 )]
 fn test_simple_function_analyze(source: &[&str], tys: &[&str], names: &[&str]) {
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let internal_resolver = Arc::new(ResolverInternal {
        id_to_def: Mutex::default(),
@ -518,7 +522,8 @@ fn test_simple_function_analyze(source: &[&str], tys: &[&str], names: &[&str]) {
 )]
 fn test_analyze(source: &[&str], res: &[&str]) {
    let print = false;
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let internal_resolver = make_internal_resolver_with_tvar(
        vec![
@ -695,7 +700,8 @@ fn test_analyze(source: &[&str], res: &[&str]) {
 )]
 fn test_inference(source: Vec<&str>, res: &[&str]) {
    let print = true;
-    let mut composer = TopLevelComposer::new(Vec::new(), ComposerConfig::default(), 64).0;
+    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let internal_resolver = make_internal_resolver_with_tvar(
        vec![
@ -775,8 +781,15 @@ fn make_internal_resolver_with_tvar(
    unifier: &mut Unifier,
    print: bool,
 ) -> Arc<ResolverInternal> {
    let list_elem_tvar = unifier.get_fresh_var(Some("list_elem".into()), None);
    let list = unifier.add_ty(TypeEnum::TObj {
        obj_id: PrimDef::List.id(),
        fields: HashMap::new(),
        params: into_var_map([list_elem_tvar]),
    });
    let res: Arc<ResolverInternal> = ResolverInternal {
-        id_to_def: Mutex::default(),
+        id_to_def: Mutex::new(HashMap::from([("list".into(), PrimDef::List.id())])),
        id_to_type: tvars
            .into_iter()
            .map(|(name, range)| {
@ -790,7 +803,7 @@ fn make_internal_resolver_with_tvar(
            })
            .collect::<HashMap<_, _>>()
            .into(),
-        class_names: Mutex::default(),
+        class_names: Mutex::new(HashMap::from([("list".into(), list)])),
    }
    .into();
    if print {
--- a/nac3core/src/toplevel/type_annotation.rs
+++ b/nac3core/src/toplevel/type_annotation.rs
@ -1,8 +1,9 @@
 use super::*;
 use crate::symbol_resolver::SymbolValue;
-use crate::toplevel::helper::PrimDef;
+use crate::toplevel::helper::{PrimDef, PrimDefDetails};
 use crate::typecheck::typedef::VarMap;
 use nac3parser::ast::Constant;
 use strum::IntoEnumIterator;
 #[derive(Clone, Debug)]
 pub enum TypeAnnotation {
@ -18,7 +19,6 @@ pub enum TypeAnnotation {
    TypeVar(Type),
    /// A `Literal` allowing a subset of literals.
    Literal(Vec<Constant>),
    List(Box<TypeAnnotation>),
    Tuple(Vec<TypeAnnotation>),
 }
@ -51,7 +51,6 @@ impl TypeAnnotation {
                format!("Literal({})", values.iter().map(|v| format!("{v:?}")).join(", "))
            }
            Virtual(ty) => format!("virtual[{}]", ty.stringify(unifier)),
            List(ty) => format!("list[{}]", ty.stringify(unifier)),
            Tuple(types) => {
                format!(
                    "tuple[{}]",
@ -145,9 +144,7 @@ pub fn parse_ast_to_type_annotation_kinds<T, S: std::hash::BuildHasher + Clone>(
         slice: &ast::Expr<T>,
         unifier: &mut Unifier,
         mut locked: HashMap<DefinitionId, Vec<Type>, S>| {
-            if ["virtual".into(), "Generic".into(), "list".into(), "tuple".into(), "Option".into()]
+            if ["virtual".into(), "Generic".into(), "tuple".into(), "Option".into()].contains(id) {
                .contains(id)
            {
                return Err(HashSet::from([format!(
                    "keywords cannot be class name (at {})",
                    expr.location
@ -236,23 +233,6 @@ pub fn parse_ast_to_type_annotation_kinds<T, S: std::hash::BuildHasher + Clone>(
            Ok(TypeAnnotation::Virtual(def.into()))
        }
        // list
        ast::ExprKind::Subscript { value, slice, .. }
            if {
                matches!(&value.node, ast::ExprKind::Name { id, .. } if id == &"list".into())
            } =>
        {
            let def_ann = parse_ast_to_type_annotation_kinds(
                resolver,
                top_level_defs,
                unifier,
                primitives,
                slice.as_ref(),
                locked,
            )?;
            Ok(TypeAnnotation::List(def_ann.into()))
        }
        // option
        ast::ExprKind::Subscript { value, slice, .. }
            if {
@ -378,6 +358,7 @@ pub fn parse_ast_to_type_annotation_kinds<T, S: std::hash::BuildHasher + Clone>(
 pub fn get_type_from_type_annotation_kinds(
    top_level_defs: &[Arc<RwLock<TopLevelDef>>],
    unifier: &mut Unifier,
    primitives: &PrimitiveStore,
    ann: &TypeAnnotation,
    subst_list: &mut Option<Vec<Type>>,
 ) -> Result<Type, HashSet<String>> {
@ -400,10 +381,43 @@ pub fn get_type_from_type_annotation_kinds(
            let param_ty = params
                .iter()
                .map(|x| {
-                    get_type_from_type_annotation_kinds(top_level_defs, unifier, x, subst_list)
+                    get_type_from_type_annotation_kinds(
                        top_level_defs,
                        unifier,
                        primitives,
                        x,
                        subst_list,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?;
            let ty = if let Some(prim_def) = PrimDef::iter().find(|prim| prim.id() == *obj_id) {
                // Primitive TopLevelDefs do not contain all fields that are present in their Type
                // counterparts, so directly perform subst on the Type instead.
                let PrimDefDetails::PrimClass { get_ty_fn, .. } = prim_def.details() else {
                    unreachable!()
                };
                let base_ty = get_ty_fn(primitives);
                let params =
                    if let TypeEnum::TObj { params, .. } = &*unifier.get_ty_immutable(base_ty) {
                        params.clone()
                    } else {
                        unreachable!()
                    };
                unifier
                    .subst(
                        get_ty_fn(primitives),
                        &params
                            .iter()
                            .zip(param_ty)
                            .map(|(obj_tv, param)| (*obj_tv.0, param))
                            .collect(),
                    )
                    .unwrap_or(base_ty)
            } else {
                let subst = {
                    // check for compatible range
                    // TODO: if allow type var to be applied(now this disallowed in the parse_to_type_annotation), need more check
@ -445,12 +459,15 @@ pub fn get_type_from_type_annotation_kinds(
                                }
                            }
-                        TypeEnum::TVar { id, range, name, loc, is_const_generic: true, .. } => {
+                            TypeEnum::TVar {
                                id, range, name, loc, is_const_generic: true, ..
                            } => {
                                let ty = range[0];
                                let ok: bool = {
                                    // create a temp type var and unify to check compatibility
                                    p == *tvar || {
-                                    let temp = unifier.get_fresh_const_generic_var(ty, *name, *loc);
+                                        let temp =
                                            unifier.get_fresh_const_generic_var(ty, *name, *loc);
                                        unifier.unify(temp.ty, p).is_ok()
                                    }
                                };
@ -470,6 +487,7 @@ pub fn get_type_from_type_annotation_kinds(
                    }
                    result
                };
                // Class Attributes keep a copy with Class Definition and are not added to objects
                let mut tobj_fields = methods
                    .iter()
                    .map(|(name, ty, _)| {
@ -488,11 +506,16 @@ pub fn get_type_from_type_annotation_kinds(
                    fields: tobj_fields,
                    params: subst,
                });
                if need_subst {
                    if let Some(wl) = subst_list.as_mut() {
                        wl.push(ty);
                    }
                }
                ty
            };
            Ok(ty)
        }
        TypeAnnotation::Primitive(ty) | TypeAnnotation::TypeVar(ty) => Ok(*ty),
@ -510,28 +533,26 @@ pub fn get_type_from_type_annotation_kinds(
            let ty = get_type_from_type_annotation_kinds(
                top_level_defs,
                unifier,
                primitives,
                ty.as_ref(),
                subst_list,
            )?;
            Ok(unifier.add_ty(TypeEnum::TVirtual { ty }))
        }
        TypeAnnotation::List(ty) => {
            let ty = get_type_from_type_annotation_kinds(
                top_level_defs,
                unifier,
                ty.as_ref(),
                subst_list,
            )?;
            Ok(unifier.add_ty(TypeEnum::TList { ty }))
        }
        TypeAnnotation::Tuple(tys) => {
            let tys = tys
                .iter()
                .map(|x| {
-                    get_type_from_type_annotation_kinds(top_level_defs, unifier, x, subst_list)
+                    get_type_from_type_annotation_kinds(
                        top_level_defs,
                        unifier,
                        primitives,
                        x,
                        subst_list,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?;
-            Ok(unifier.add_ty(TypeEnum::TTuple { ty: tys }))
+            Ok(unifier.add_ty(TypeEnum::TTuple { ty: tys, is_vararg_ctx: false }))
        }
    }
 }
@ -564,7 +585,7 @@ pub fn get_type_var_contained_in_type_annotation(ann: &TypeAnnotation) -> Vec<Ty
    let mut result: Vec<TypeAnnotation> = Vec::new();
    match ann {
        TypeAnnotation::TypeVar(..) => result.push(ann.clone()),
-        TypeAnnotation::Virtual(ann) | TypeAnnotation::List(ann) => {
+        TypeAnnotation::Virtual(ann) => {
            result.extend(get_type_var_contained_in_type_annotation(ann.as_ref()));
        }
        TypeAnnotation::CustomClass { params, .. } => {
@ -605,8 +626,7 @@ pub fn check_overload_type_annotation_compatible(
            a == b
        }
-        (TypeAnnotation::Virtual(a), TypeAnnotation::Virtual(b))
+        (TypeAnnotation::Virtual(a), TypeAnnotation::Virtual(b)) => {
        | (TypeAnnotation::List(a), TypeAnnotation::List(b)) => {
            check_overload_type_annotation_compatible(a.as_ref(), b.as_ref(), unifier)
        }
--- a/nac3core/src/typecheck/function_check.rs
+++ b/nac3core/src/typecheck/function_check.rs
@ -1,7 +1,7 @@
-use crate::typecheck::typedef::TypeEnum;
+use crate::toplevel::helper::PrimDef;
 use super::type_inferencer::Inferencer;
-use super::typedef::Type;
+use super::typedef::{Type, TypeEnum};
 use nac3parser::ast::{
    self, Constant, Expr, ExprKind,
    Operator::{LShift, RShift},
@ -34,13 +34,18 @@ impl<'a> Inferencer<'a> {
                self.should_have_value(pattern)?;
                Ok(())
            }
-            ExprKind::Tuple { elts, .. } => {
+            ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
                for elt in elts {
                    self.check_pattern(elt, defined_identifiers)?;
                    self.should_have_value(elt)?;
                }
                Ok(())
            }
            ExprKind::Starred { value, .. } => {
                self.check_pattern(value, defined_identifiers)?;
                self.should_have_value(value)?;
                Ok(())
            }
            ExprKind::Subscript { value, slice, .. } => {
                self.check_expr(value, defined_identifiers)?;
                self.should_have_value(value)?;
@ -69,6 +74,7 @@ impl<'a> Inferencer<'a> {
        // there are some cases where the custom field is None
        if let Some(ty) = &expr.custom {
            if !matches!(&expr.node, ExprKind::Constant { value: Constant::Ellipsis, .. })
                && !ty.obj_id(self.unifier).is_some_and(|id| id == PrimDef::List.id())
                && !self.unifier.is_concrete(*ty, &self.function_data.bound_variables)
            {
                return Err(HashSet::from([format!(
@ -206,6 +212,9 @@ impl<'a> Inferencer<'a> {
    /// This is a workaround preventing the caller from using a variable `alloca`-ed in the body, which
    /// is freed when the function returns.
    fn check_return_value_ty(&mut self, ret_ty: Type) -> bool {
        if cfg!(feature = "no-escape-analysis") {
            true
        } else {
            match &*self.unifier.get_ty_immutable(ret_ty) {
                TypeEnum::TObj { .. } => [
                    self.primitives.int32,
@ -217,10 +226,11 @@ impl<'a> Inferencer<'a> {
                ]
                .iter()
                .any(|allowed_ty| self.unifier.unioned(ret_ty, *allowed_ty)),
-            TypeEnum::TTuple { ty } => ty.iter().all(|t| self.check_return_value_ty(*t)),
+                TypeEnum::TTuple { ty, .. } => ty.iter().all(|t| self.check_return_value_ty(*t)),
                _ => false,
            }
        }
    }
    // check statements for proper identifier def-use and return on all paths
    fn check_stmt(
--- a/nac3core/src/typecheck/magic_methods.rs
+++ b/nac3core/src/typecheck/magic_methods.rs
@ -5,7 +5,7 @@ use crate::typecheck::{
    type_inferencer::*,
    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
 };
-use itertools::Itertools;
+use itertools::{iproduct, Itertools};
 use nac3parser::ast::StrRef;
 use nac3parser::ast::{Cmpop, Operator, Unaryop};
 use std::cmp::max;
@ -13,67 +13,138 @@ use std::collections::HashMap;
 use std::rc::Rc;
 use strum::IntoEnumIterator;
 /// The variant of a binary operator.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BinopVariant {
    /// The normal variant.
    /// For addition, it would be `+`.
    Normal,
    /// The "Augmented Assigning Operator" variant.
    /// For addition, it would be `+=`.
    AugAssign,
 }
 /// A binary operator with its variant.
 #[derive(Debug, Clone, Copy)]
 pub struct Binop {
    /// The base [`Operator`] of this binary operator.
    pub base: Operator,
    /// The variant of this binary operator.
    pub variant: BinopVariant,
 }
 impl Binop {
    /// Make a [`Binop`] of the normal variant from an [`Operator`].
    #[must_use]
-pub fn binop_name(op: Operator) -> &'static str {
+    pub fn normal(base: Operator) -> Self {
-    match op {
+        Binop { base, variant: BinopVariant::Normal }
-        Operator::Add => "__add__",
+    }
-        Operator::Sub => "__sub__",
+
-        Operator::Div => "__truediv__",
+    /// Make a [`Binop`] of the aug assign variant from an [`Operator`].
-        Operator::Mod => "__mod__",
+    #[must_use]
-        Operator::Mult => "__mul__",
+    pub fn aug_assign(base: Operator) -> Self {
-        Operator::Pow => "__pow__",
+        Binop { base, variant: BinopVariant::AugAssign }
        Operator::BitOr => "__or__",
        Operator::BitXor => "__xor__",
        Operator::BitAnd => "__and__",
        Operator::LShift => "__lshift__",
        Operator::RShift => "__rshift__",
        Operator::FloorDiv => "__floordiv__",
        Operator::MatMult => "__matmul__",
    }
 }
-#[must_use]
+/// Details about an operator (unary, binary, etc...) in Python
-pub fn binop_assign_name(op: Operator) -> &'static str {
+#[derive(Debug, Clone, Copy)]
-    match op {
+pub struct OpInfo {
-        Operator::Add => "__iadd__",
+    /// The method name of the binary operator.
-        Operator::Sub => "__isub__",
+    /// For addition, this would be `__add__`, and `__iadd__` if
-        Operator::Div => "__itruediv__",
+    /// it is the augmented assigning variant.
-        Operator::Mod => "__imod__",
+    pub method_name: &'static str,
-        Operator::Mult => "__imul__",
+    /// The symbol of the binary operator.
-        Operator::Pow => "__ipow__",
+    /// For addition, this would be `+`, and `+=` if
-        Operator::BitOr => "__ior__",
+    /// it is the augmented assigning variant.
-        Operator::BitXor => "__ixor__",
+    pub symbol: &'static str,
        Operator::BitAnd => "__iand__",
        Operator::LShift => "__ilshift__",
        Operator::RShift => "__irshift__",
        Operator::FloorDiv => "__ifloordiv__",
        Operator::MatMult => "__imatmul__",
    }
 }
-#[must_use]
+/// Helper macro to conveniently build an [`OpInfo`].
-pub fn unaryop_name(op: Unaryop) -> &'static str {
+///
-    match op {
+/// Example usage: `make_info("add", "+")` generates `OpInfo { name: "__add__", symbol: "+" }`
-        Unaryop::UAdd => "__pos__",
+macro_rules! make_op_info {
-        Unaryop::USub => "__neg__",
+    ($name:expr, $symbol:expr) => {
-        Unaryop::Not => "__not__",
+        OpInfo { method_name: concat!("__", $name, "__"), symbol: $symbol }
-        Unaryop::Invert => "__inv__",
+    };
    }
 }
-#[must_use]
+pub trait HasOpInfo {
-pub fn comparison_name(op: Cmpop) -> Option<&'static str> {
+    fn op_info(&self) -> OpInfo;
 }
 fn try_get_cmpop_info(op: Cmpop) -> Option<OpInfo> {
    match op {
-        Cmpop::Lt => Some("__lt__"),
+        Cmpop::Lt => Some(make_op_info!("lt", "<")),
-        Cmpop::LtE => Some("__le__"),
+        Cmpop::LtE => Some(make_op_info!("le", "<=")),
-        Cmpop::Gt => Some("__gt__"),
+        Cmpop::Gt => Some(make_op_info!("gt", ">")),
-        Cmpop::GtE => Some("__ge__"),
+        Cmpop::GtE => Some(make_op_info!("ge", ">=")),
-        Cmpop::Eq => Some("__eq__"),
+        Cmpop::Eq => Some(make_op_info!("eq", "==")),
-        Cmpop::NotEq => Some("__ne__"),
+        Cmpop::NotEq => Some(make_op_info!("ne", "!=")),
        _ => None,
    }
 }
 impl OpInfo {
    #[must_use]
    pub fn supports_cmpop(op: Cmpop) -> bool {
        try_get_cmpop_info(op).is_some()
    }
 }
 impl HasOpInfo for Cmpop {
    fn op_info(&self) -> OpInfo {
        try_get_cmpop_info(*self).expect("{self:?} is not supported")
    }
 }
 impl HasOpInfo for Binop {
    fn op_info(&self) -> OpInfo {
        // Helper macro to generate both the normal variant [`OpInfo`] and the
        // augmented assigning variant [`OpInfo`] for a binary operator conveniently.
        macro_rules! info {
            ($name:literal, $symbol:literal) => {
                (
                    make_op_info!($name, $symbol),
                    make_op_info!(concat!("i", $name), concat!($symbol, "=")),
                )
            };
        }
        let (normal_variant, aug_assign_variant) = match self.base {
            Operator::Add => info!("add", "+"),
            Operator::Sub => info!("sub", "-"),
            Operator::Div => info!("truediv", "/"),
            Operator::Mod => info!("mod", "%"),
            Operator::Mult => info!("mul", "*"),
            Operator::Pow => info!("pow", "**"),
            Operator::BitOr => info!("or", "|"),
            Operator::BitXor => info!("xor", "^"),
            Operator::BitAnd => info!("and", "&"),
            Operator::LShift => info!("lshift", "<<"),
            Operator::RShift => info!("rshift", ">>"),
            Operator::FloorDiv => info!("floordiv", "//"),
            Operator::MatMult => info!("matmul", "@"),
        };
        match self.variant {
            BinopVariant::Normal => normal_variant,
            BinopVariant::AugAssign => aug_assign_variant,
        }
    }
 }
 impl HasOpInfo for Unaryop {
    fn op_info(&self) -> OpInfo {
        match self {
            Unaryop::UAdd => make_op_info!("pos", "+"),
            Unaryop::USub => make_op_info!("neg", "-"),
            Unaryop::Not => make_op_info!("not", "not"), // i.e., `not False`, so the symbol is just `not`.
            Unaryop::Invert => make_op_info!("inv", "~"),
        }
    }
 }
 pub(super) fn with_fields<F>(unifier: &mut Unifier, ty: Type, f: F)
 where
    F: FnOnce(&mut Unifier, &mut HashMap<StrRef, (Type, bool)>),
@ -115,23 +186,9 @@ pub fn impl_binop(
        let ret_ty = ret_ty.unwrap_or_else(|| unifier.get_fresh_var(None, None).ty);
-        for op in ops {
+        for (base_op, variant) in iproduct!(ops, [BinopVariant::Normal, BinopVariant::AugAssign]) {
-            fields.insert(binop_name(*op).into(), {
+            let op = Binop { base: *base_op, variant };
-                (
+            fields.insert(op.op_info().method_name.into(), {
                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        ret: ret_ty,
                        vars: function_vars.clone(),
                        args: vec![FuncArg {
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
                        }],
                    })),
                    false,
                )
            });
            fields.insert(binop_assign_name(*op).into(), {
                (
                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        ret: ret_ty,
@ -140,6 +197,7 @@ pub fn impl_binop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
                            is_vararg: false,
                        }],
                    })),
                    false,
@ -155,7 +213,7 @@ pub fn impl_unaryop(unifier: &mut Unifier, ty: Type, ret_ty: Option<Type>, ops:
        for op in ops {
            fields.insert(
-                unaryop_name(*op).into(),
+                op.op_info().method_name.into(),
                (
                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        ret: ret_ty,
@ -195,7 +253,7 @@ pub fn impl_cmpop(
        for op in ops {
            fields.insert(
-                comparison_name(*op).unwrap().into(),
+                op.op_info().method_name.into(),
                (
                    unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        ret: ret_ty,
@ -204,6 +262,7 @@ pub fn impl_cmpop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
                            is_vararg: false,
                        }],
                    })),
                    false,
@ -429,12 +488,29 @@ pub fn typeof_binop(
    lhs: Type,
    rhs: Type,
 ) -> Result<Option<Type>, String> {
    let op = Binop { base: op, variant: BinopVariant::Normal };
    let is_left_list = lhs.obj_id(unifier).is_some_and(|id| id == PrimDef::List.id());
    let is_right_list = rhs.obj_id(unifier).is_some_and(|id| id == PrimDef::List.id());
    let is_left_ndarray = lhs.obj_id(unifier).is_some_and(|id| id == PrimDef::NDArray.id());
    let is_right_ndarray = rhs.obj_id(unifier).is_some_and(|id| id == PrimDef::NDArray.id());
-    Ok(Some(match op {
+    Ok(Some(match op.base {
        Operator::Add | Operator::Sub | Operator::Mult | Operator::Mod | Operator::FloorDiv => {
-            if is_left_ndarray || is_right_ndarray {
+            if is_left_list || is_right_list {
                if ![Operator::Add, Operator::Mult].contains(&op.base) {
                    return Err(format!(
                        "Binary operator {} not supported for list",
                        op.op_info().symbol
                    ));
                }
                if is_left_list {
                    lhs
                } else {
                    rhs
                }
            } else if is_left_ndarray || is_right_ndarray {
                typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?
            } else if unifier.unioned(lhs, rhs) {
                lhs
@ -444,6 +520,23 @@ pub fn typeof_binop(
        }
        Operator::MatMult => {
            // NOTE: NumPy matmul's LHS and RHS must both be ndarrays. Scalars are not allowed.
            match (&*unifier.get_ty(lhs), &*unifier.get_ty(rhs)) {
                (
                    TypeEnum::TObj { obj_id: lhs_obj_id, .. },
                    TypeEnum::TObj { obj_id: rhs_obj_id, .. },
                ) if *lhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap()
                    && *rhs_obj_id == primitives.ndarray.obj_id(unifier).unwrap() =>
                {
                    // LHS and RHS have valid types
                }
                _ => {
                    let lhs_str = unifier.stringify(lhs);
                    let rhs_str = unifier.stringify(rhs);
                    return Err(format!("ndarray.__matmul__ only accepts ndarray operands, but left operand has type {lhs_str}, and right operand has type {rhs_str}"));
                }
            }
            let (_, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
            let lhs_ndims = match &*unifier.get_ty_immutable(lhs_ndims) {
                TypeEnum::TLiteral { values, .. } => {
@ -604,6 +697,8 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
        bool: bool_t,
        uint32: uint32_t,
        uint64: uint64_t,
        str: str_t,
        list: list_t,
        ndarray: ndarray_t,
        ..
    } = *store;
@ -648,6 +743,14 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
    impl_sign(unifier, store, bool_t, Some(int32_t));
    impl_eq(unifier, store, bool_t, &[bool_t, ndarray_bool_t], None);
    /* str ========= */
    impl_cmpop(unifier, store, str_t, &[str_t], &[Cmpop::Eq, Cmpop::NotEq], Some(bool_t));
    /* list ======== */
    impl_binop(unifier, store, list_t, &[list_t], Some(list_t), &[Operator::Add]);
    impl_binop(unifier, store, list_t, &[int32_t, int64_t], Some(list_t), &[Operator::Mult]);
    impl_cmpop(unifier, store, list_t, &[list_t], &[Cmpop::Eq, Cmpop::NotEq], Some(bool_t));
    /* ndarray ===== */
    let ndarray_usized_ndims_tvar =
        unifier.get_fresh_const_generic_var(size_t, Some("ndarray_ndims".into()), None);
--- a/nac3core/src/typecheck/type_error.rs
+++ b/nac3core/src/typecheck/type_error.rs
@ -1,24 +1,46 @@
 use std::collections::HashMap;
 use std::fmt::Display;
-use crate::typecheck::typedef::TypeEnum;
+use crate::typecheck::{magic_methods::HasOpInfo, typedef::TypeEnum};
-use super::typedef::{RecordKey, Type, Unifier};
+use super::{
-use nac3parser::ast::{Location, StrRef};
+    magic_methods::Binop,
    typedef::{RecordKey, Type, Unifier},
 };
 use itertools::Itertools;
 use nac3parser::ast::{Cmpop, Location, StrRef};
 #[derive(Debug, Clone)]
 pub enum TypeErrorKind {
-    TooManyArguments {
+    GotMultipleValues {
-        expected: usize,
+        name: StrRef,
-        got: usize,
+    },
    TooManyArguments {
        expected_min_count: usize,
        expected_max_count: usize,
        got_count: usize,
    },
    MissingArgs {
        missing_arg_names: Vec<StrRef>,
    },
    MissingArgs(String),
    UnknownArgName(StrRef),
    IncorrectArgType {
        name: StrRef,
        expected: Type,
        got: Type,
    },
    UnsupportedBinaryOpTypes {
        operator: Binop,
        lhs_type: Type,
        rhs_type: Type,
        expected_rhs_type: Type,
    },
    UnsupportedComparsionOpTypes {
        operator: Cmpop,
        lhs_type: Type,
        rhs_type: Type,
        expected_rhs_type: Type,
    },
    FieldUnificationError {
        field: RecordKey,
        types: (Type, Type),
@ -34,6 +56,7 @@ pub enum TypeErrorKind {
    },
    RequiresTypeAnn,
    PolymorphicFunctionPointer,
    NoSuchAttribute(RecordKey, Type),
 }
 #[derive(Debug, Clone)]
@ -77,19 +100,49 @@ impl<'a> Display for DisplayTypeError<'a> {
        use TypeErrorKind::*;
        let mut notes = Some(HashMap::new());
        match &self.err.kind {
-            TooManyArguments { expected, got } => {
+            GotMultipleValues { name } => {
-                write!(f, "Too many arguments. Expected {expected} but got {got}")
+                write!(f, "For multiple values for parameter {name}")
            }
-            MissingArgs(args) => {
+            TooManyArguments { expected_min_count, expected_max_count, got_count } => {
                debug_assert!(expected_min_count <= expected_max_count);
                if expected_min_count == expected_max_count {
                    let expected_count = expected_min_count; // or expected_max_count
                    write!(f, "Too many arguments. Expected {expected_count} but got {got_count}")
                } else {
                    write!(f, "Too many arguments. Expected {expected_min_count} to {expected_max_count} arguments but got {got_count}")
                }
            }
            MissingArgs { missing_arg_names } => {
                let args = missing_arg_names.iter().join(", ");
                write!(f, "Missing arguments: {args}")
            }
            UnsupportedBinaryOpTypes { operator, lhs_type, rhs_type, expected_rhs_type } => {
                let op_symbol = operator.op_info().symbol;
                let lhs_type_str = self.unifier.stringify_with_notes(*lhs_type, &mut notes);
                let rhs_type_str = self.unifier.stringify_with_notes(*rhs_type, &mut notes);
                let expected_rhs_type_str =
                    self.unifier.stringify_with_notes(*expected_rhs_type, &mut notes);
                write!(f, "Unsupported operand type(s) for {op_symbol}: '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})")
            }
            UnsupportedComparsionOpTypes { operator, lhs_type, rhs_type, expected_rhs_type } => {
                let op_symbol = operator.op_info().symbol;
                let lhs_type_str = self.unifier.stringify_with_notes(*lhs_type, &mut notes);
                let rhs_type_str = self.unifier.stringify_with_notes(*rhs_type, &mut notes);
                let expected_rhs_type_str =
                    self.unifier.stringify_with_notes(*expected_rhs_type, &mut notes);
                write!(f, "'{op_symbol}' not supported between instances of '{lhs_type_str}' and '{rhs_type_str}' (right operand should have type {expected_rhs_type_str})")
            }
            UnknownArgName(name) => {
                write!(f, "Unknown argument name: {name}")
            }
            IncorrectArgType { name, expected, got } => {
                let expected = self.unifier.stringify_with_notes(*expected, &mut notes);
                let got = self.unifier.stringify_with_notes(*got, &mut notes);
-                write!(f, "Incorrect argument type for {name}. Expected {expected}, but got {got}")
+                write!(f, "Incorrect argument type for parameter {name}. Expected {expected}, but got {got}")
            }
            FieldUnificationError { field, types, loc } => {
                let lhs = self.unifier.stringify_with_notes(types.0, &mut notes);
@ -130,9 +183,10 @@ impl<'a> Display for DisplayTypeError<'a> {
                        }
                        result
                    }
-                    (TypeEnum::TTuple { ty: ty1 }, TypeEnum::TTuple { ty: ty2 })
+                    (
-                        if ty1.len() != ty2.len() =>
+                        TypeEnum::TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
-                    {
+                        TypeEnum::TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
                    ) if !is_vararg1 && !is_vararg2 && ty1.len() != ty2.len() => {
                        let t1 = self.unifier.stringify_with_notes(*t1, &mut notes);
                        let t2 = self.unifier.stringify_with_notes(*t2, &mut notes);
                        write!(f, "Tuple length mismatch: got {t1} and {t2}")
@ -156,6 +210,10 @@ impl<'a> Display for DisplayTypeError<'a> {
                let t = self.unifier.stringify_with_notes(*t, &mut notes);
                write!(f, "`{t}::{name}` field/method does not exist")
            }
            NoSuchAttribute(name, t) => {
                let t = self.unifier.stringify_with_notes(*t, &mut notes);
                write!(f, "`{t}::{name}` is not a class attribute")
            }
            TupleIndexOutOfBounds { index, len } => {
                write!(
                    f,
--- a/nac3core/src/typecheck/type_inferencer/mod.rs
+++ b/nac3core/src/typecheck/type_inferencer/mod.rs
--- a/nac3core/src/typecheck/type_inferencer/test.rs
+++ b/nac3core/src/typecheck/type_inferencer/test.rs
@ -83,7 +83,12 @@ impl TestEnvironment {
        });
        with_fields(&mut unifier, int32, |unifier, fields| {
            let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
+                args: vec![FuncArg {
                    name: "other".into(),
                    ty: int32,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: int32,
                vars: VarMap::new(),
            }));
@ -139,6 +144,12 @@ impl TestEnvironment {
            fields: HashMap::new(),
            params: VarMap::new(),
        });
        let list_elem_tvar = unifier.get_fresh_var(Some("list_elem".into()), None);
        let list = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::List.id(),
            fields: HashMap::new(),
            params: into_var_map([list_elem_tvar]),
        });
        let ndarray_dtype_tvar = unifier.get_fresh_var(Some("ndarray_dtype".into()), None);
        let ndarray_ndims_tvar =
            unifier.get_fresh_const_generic_var(uint64, Some("ndarray_ndims".into()), None);
@ -159,6 +170,7 @@ impl TestEnvironment {
            uint32,
            uint64,
            option,
            list,
            ndarray,
            size_t: 64,
        };
@ -217,7 +229,12 @@ impl TestEnvironment {
        });
        with_fields(&mut unifier, int32, |unifier, fields| {
            let add_ty = unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "other".into(), ty: int32, default_value: None }],
+                args: vec![FuncArg {
                    name: "other".into(),
                    ty: int32,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: int32,
                vars: VarMap::new(),
            }));
@ -273,13 +290,33 @@ impl TestEnvironment {
            fields: HashMap::new(),
            params: VarMap::new(),
        });
        let list_elem_tvar = unifier.get_fresh_var(Some("list_elem".into()), None);
        let list = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::List.id(),
            fields: HashMap::new(),
            params: into_var_map([list_elem_tvar]),
        });
        let ndarray = unifier.add_ty(TypeEnum::TObj {
            obj_id: PrimDef::NDArray.id(),
            fields: HashMap::new(),
            params: VarMap::new(),
        });
        identifier_mapping.insert("None".into(), none);
-        for (i, name) in ["int32", "int64", "float", "bool", "none", "range", "str", "Exception"]
+        for (i, name) in [
            "int32",
            "int64",
            "float",
            "bool",
            "none",
            "range",
            "str",
            "Exception",
            "uint32",
            "uint64",
            "Option",
            "list",
            "ndarray",
        ]
        .iter()
        .enumerate()
        {
@ -289,6 +326,7 @@ impl TestEnvironment {
                    object_id: DefinitionId(i),
                    type_vars: Vec::default(),
                    fields: Vec::default(),
                    attributes: Vec::default(),
                    methods: Vec::default(),
                    ancestors: Vec::default(),
                    resolver: None,
@ -298,7 +336,7 @@ impl TestEnvironment {
                .into(),
            );
        }
-        let defs = 7;
+        let defs = 12;
        let primitives = PrimitiveStore {
            int32,
@ -312,6 +350,7 @@ impl TestEnvironment {
            uint32,
            uint64,
            option,
            list,
            ndarray,
            size_t: 64,
        };
@ -331,6 +370,7 @@ impl TestEnvironment {
                object_id: DefinitionId(defs + 1),
                type_vars: vec![tvar.ty],
                fields: [("a".into(), tvar.ty, true)].into(),
                attributes: Vec::default(),
                methods: Vec::default(),
                ancestors: Vec::default(),
                resolver: None,
@ -365,6 +405,7 @@ impl TestEnvironment {
                object_id: DefinitionId(defs + 2),
                type_vars: Vec::default(),
                fields: [("a".into(), int32, true), ("b".into(), fun, true)].into(),
                attributes: Vec::default(),
                methods: Vec::default(),
                ancestors: Vec::default(),
                resolver: None,
@ -393,6 +434,7 @@ impl TestEnvironment {
                object_id: DefinitionId(defs + 3),
                type_vars: Vec::default(),
                fields: [("a".into(), bool, true), ("b".into(), fun, false)].into(),
                attributes: Vec::default(),
                methods: Vec::default(),
                ancestors: Vec::default(),
                resolver: None,
@ -420,6 +462,11 @@ impl TestEnvironment {
            "range".into(),
            "str".into(),
            "exception".into(),
            "uint32".into(),
            "uint64".into(),
            "option".into(),
            "list".into(),
            "ndarray".into(),
            "Foo".into(),
            "Bar".into(),
            "Bar2".into(),
--- a/nac3core/src/typecheck/typedef/mod.rs
+++ b/nac3core/src/typecheck/typedef/mod.rs
@ -1,20 +1,21 @@
-use indexmap::IndexMap;
+use super::magic_methods::{Binop, HasOpInfo};
 use itertools::Itertools;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::{self, Display};
 use std::iter::zip;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::{borrow::Cow, collections::HashSet};
 use nac3parser::ast::{Location, StrRef};
 use super::type_error::{TypeError, TypeErrorKind};
 use super::unification_table::{UnificationKey, UnificationTable};
 use crate::symbol_resolver::SymbolValue;
 use crate::toplevel::helper::PrimDef;
 use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
 use crate::typecheck::magic_methods::OpInfo;
 use crate::typecheck::type_inferencer::PrimitiveStore;
 use indexmap::IndexMap;
 use itertools::{repeat_n, Itertools};
 use nac3parser::ast::{Cmpop, Location, StrRef, Unaryop};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::{self, Display};
 use std::iter::{repeat, zip};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::{borrow::Cow, collections::HashSet};
 #[cfg(test)]
 mod test;
@ -73,6 +74,28 @@ pub fn iter_type_vars(var_map: &VarMap) -> impl Iterator<Item = TypeVar> + '_ {
    var_map.iter().map(|(&id, &ty)| TypeVar { id, ty })
 }
 #[derive(Debug, Clone)]
 pub enum OperatorInfo {
    /// The call was written as an unary operation, e.g., `~a` or `not a`.
    IsUnaryOp {
        /// The [`Type`] of the `self` object
        self_type: Type,
        operator: Unaryop,
    },
    /// The call was written as a binary operation, e.g., `a + b` or `a += b`.
    IsBinaryOp {
        /// The [`Type`] of the `self` object
        self_type: Type,
        operator: Binop,
    },
    /// The call was written as a binary comparison operation, e.g., `a < b`.
    IsComparisonOp {
        /// The [`Type`] of the `self` object
        self_type: Type,
        operator: Cmpop,
    },
 }
 #[derive(Clone)]
 pub struct Call {
    pub posargs: Vec<Type>,
@ -80,6 +103,9 @@ pub struct Call {
    pub ret: Type,
    pub fun: RefCell<Option<Type>>,
    pub loc: Option<Location>,
    /// Details about the associated Python user operator expression of this call, if any.
    pub operator_info: Option<OperatorInfo>,
 }
 #[derive(Debug, Clone)]
@ -87,6 +113,14 @@ pub struct FuncArg {
    pub name: StrRef,
    pub ty: Type,
    pub default_value: Option<SymbolValue>,
    pub is_vararg: bool,
 }
 impl FuncArg {
    #[must_use]
    pub fn is_required(&self) -> bool {
        self.default_value.is_none()
    }
 }
 #[derive(Debug, Clone)]
@ -198,12 +232,12 @@ pub enum TypeEnum {
    TTuple {
        /// The types of elements present in this tuple.
        ty: Vec<Type>,
    },
-    /// A list type.
+        /// Whether this tuple is used in a vararg context.
-    TList {
+        ///
-        /// The type of elements present in this list.
+        /// If `true`, `ty` must only contain one type, and the tuple is assumed to contain any
-        ty: Type,
+        /// number of `ty`-typed values.
        is_vararg_ctx: bool,
    },
    /// An object type.
@ -239,7 +273,6 @@ impl TypeEnum {
            TypeEnum::TVar { .. } => "TVar",
            TypeEnum::TLiteral { .. } => "TConstant",
            TypeEnum::TTuple { .. } => "TTuple",
            TypeEnum::TList { .. } => "TList",
            TypeEnum::TObj { .. } => "TObj",
            TypeEnum::TVirtual { .. } => "TVirtual",
            TypeEnum::TCall { .. } => "TCall",
@ -475,13 +508,31 @@ impl Unifier {
                    )
                }
            }
-            TypeEnum::TList { ty } => self
+            TypeEnum::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
-                .get_instantiations(*ty)
+                let tv = iter_type_vars(params).nth(0).unwrap();
-                .map(|ty| ty.iter().map(|&ty| self.add_ty(TypeEnum::TList { ty })).collect_vec()),
+
                let tv_id = if let TypeEnum::TVar { id, .. } =
                    self.unification_table.probe_value(tv.ty).as_ref()
                {
                    *id
                } else {
                    tv.id
                };
                self.get_instantiations(tv.ty).map(|ty_insts| {
                    ty_insts
                        .iter()
                        .map(|&ty_inst| {
                            self.subst(ty, &into_var_map([TypeVar { id: tv_id, ty: ty_inst }]))
                                .unwrap_or(ty)
                        })
                        .collect()
                })
            }
            TypeEnum::TVirtual { ty } => self.get_instantiations(*ty).map(|ty| {
                ty.iter().map(|&ty| self.add_ty(TypeEnum::TVirtual { ty })).collect_vec()
            }),
-            TypeEnum::TTuple { ty } => {
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
                let tuples = ty
                    .iter()
                    .map(|ty| self.get_instantiations(*ty).unwrap_or_else(|| vec![*ty]))
@ -491,7 +542,12 @@ impl Unifier {
                    None
                } else {
                    Some(
-                        tuples.into_iter().map(|ty| self.add_ty(TypeEnum::TTuple { ty })).collect(),
+                        tuples
                            .into_iter()
                            .map(|ty| {
                                self.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: *is_vararg_ctx })
                            })
                            .collect(),
                    )
                }
            }
@ -534,10 +590,8 @@ impl Unifier {
            TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
            TCall { .. } => false,
-            TList { ty }
+            TVirtual { ty } => self.is_concrete(*ty, allowed_typevars),
-            | TVirtual { ty } => self.is_concrete(*ty, allowed_typevars),
+            TTuple { ty, .. } => ty.iter().all(|ty| self.is_concrete(*ty, allowed_typevars)),
            TTuple { ty } => ty.iter().all(|ty| self.is_concrete(*ty, allowed_typevars)),
            TObj { params: vars, .. } => {
                vars.values().all(|ty| self.is_concrete(*ty, allowed_typevars))
            }
@ -562,61 +616,232 @@ impl Unifier {
        call: &Call,
        b: Type,
        signature: &FunSignature,
        required: &[StrRef],
    ) -> Result<(), TypeError> {
        /*
            NOTE: scenarios to consider:
            ```python
            def func1(x: int32, y: int32, z: int32 = 5): pass
            # Normal scenarios
            func1(23, 45) # OK, z has default
            func1(23, 45, 67) # OK, z's default is overwritten
            func1(x = 23, y = 45) # OK, user is using kwargs to set positional args
            func1(y = 45, x = 23) # OK, kwargs order doesn't matter
            # Error scenarios
            func1() # ERROR: Missing arguments: x, y
            func1(23) # ERROR: Missing arguments: y
            func1(z = 23) # ERROR: Missing arguments: x, y
            func1(x = 23) # ERROR: Missing arguments: y
            func1(23, 45, x = 5) # ERROR: Got multiple values for x
            func1(23, 45, x = 5, y = 6) # ERROR: Got multiple values for x (y too but Python does not report it)
            func1(23, 45, 67, z = 89) # ERROR: Got multiple values for z
            func1(23, 45, 67, 89) # ERROR: Function only takes from 2 to 3 positional arguments but 4 were given.
            func1(23, 45, 67, w = 3) # ERROR: Got an unexpected keyword argument 'w'
            # Error scenarios that do not need to be handled here.
            func1(23, 45, z = 67, z = 89) # ERROR: Keyword argument repeated: z, the parser panics on this.
            ```
        */
        struct ParamInfo<'a> {
            /// Has this parameter been supplied with an argument already?
            has_been_supplied: bool,
            /// The corresponding [`FuncArg`] instance of this parameter (for fast table lookups)
            param: &'a FuncArg,
        }
        let snapshot = self.unification_table.get_snapshot();
        if self.snapshot.is_none() {
            self.snapshot = Some(snapshot);
        }
-        let Call { posargs, kwargs, ret, fun, loc } = call;
+        // Get details about the function signature/parameters.
-        let instantiated = self.instantiate_fun(b, signature);
+        let num_params = signature.args.len();
-        let r = self.get_ty(instantiated);
+        let is_vararg = signature.args.iter().any(|arg| arg.is_vararg);
-        let r = r.as_ref();
+
-        let TypeEnum::TFunc(signature) = r else { unreachable!() };
+        // Force the type vars in `b` and `signature' to be up-to-date.
-        // we check to make sure that all required arguments (those without default
+        let b = self.instantiate_fun(b, signature);
-        // arguments) are provided, and do not provide the same argument twice.
+        let TypeEnum::TFunc(signature) = &*self.get_ty(b) else { unreachable!() };
-        let mut required = required.to_vec();
+
-        let mut all_names: Vec<_> = signature.args.iter().map(|v| (v.name, v.ty)).rev().collect();
+        // Get details about the input arguments
-        for (i, t) in posargs.iter().enumerate() {
+        let Call { posargs, kwargs, ret, fun, loc, operator_info } = call;
-            if signature.args.len() <= i {
+        let num_args = posargs.len() + kwargs.len();
        // Now we check the arguments against the parameters,
        // and depending on what `call_info` is, we might change how `unify_call()` behaves
        // to improve user error messages when type checking fails.
        match operator_info {
            Some(OperatorInfo::IsBinaryOp { self_type, operator }) => {
                // The call is written in the form of (say) `a + b`.
                // Technically, it is `a.__add__(b)`, and they have the following constraints:
                assert_eq!(posargs.len(), 1);
                assert_eq!(kwargs.len(), 0);
                assert_eq!(num_params, 1);
                let other_type = posargs[0]; // the second operand
                let expected_other_type = signature.args[0].ty;
                let ok = self.unify_impl(expected_other_type, other_type, false).is_ok();
                if !ok {
                    self.restore_snapshot();
                    return Err(TypeError::new(
-                    TypeErrorKind::TooManyArguments {
+                        TypeErrorKind::UnsupportedBinaryOpTypes {
-                        expected: signature.args.len(),
+                            operator: *operator,
-                        got: posargs.len() + kwargs.len(),
+                            lhs_type: *self_type,
                            rhs_type: other_type,
                            expected_rhs_type: expected_other_type,
                        },
                        *loc,
                    ));
                }
            required.pop();
            let (name, expected) = all_names.pop().unwrap();
            self.unify_impl(expected, *t, false).map_err(|_| {
                self.restore_snapshot();
                TypeError::new(TypeErrorKind::IncorrectArgType { name, expected, got: *t }, *loc)
            })?;
            }
-        for (k, t) in kwargs {
+            Some(OperatorInfo::IsComparisonOp { self_type, operator })
-            if let Some(i) = required.iter().position(|v| v == k) {
+                if OpInfo::supports_cmpop(*operator) // Otherwise that comparison operator is not supported.
-                required.remove(i);
+                =>
-            }
+            {
-            let i = all_names.iter().position(|v| &v.0 == k).ok_or_else(|| {
+                // The call is written in the form of (say) `a <= b`.
-                self.restore_snapshot();
+                // Technically, it is `a.__le__(b)`, and they have the following constraints:
-                TypeError::new(TypeErrorKind::UnknownArgName(*k), *loc)
+                assert_eq!(posargs.len(), 1);
-            })?;
+                assert_eq!(kwargs.len(), 0);
-            let (name, expected) = all_names.remove(i);
+                assert_eq!(num_params, 1);
-            self.unify_impl(expected, *t, false).map_err(|_| {
+
-                self.restore_snapshot();
+                let other_type = posargs[0]; // the second operand
-                TypeError::new(TypeErrorKind::IncorrectArgType { name, expected, got: *t }, *loc)
+                let expected_other_type = signature.args[0].ty;
-            })?;
+
-        }
+                let ok = self.unify_impl(expected_other_type, other_type, false).is_ok();
-        if !required.is_empty() {
+                if !ok {
                    self.restore_snapshot();
                    return Err(TypeError::new(
-                TypeErrorKind::MissingArgs(required.iter().join(", ")),
+                        TypeErrorKind::UnsupportedComparsionOpTypes {
                            operator: *operator,
                            lhs_type: *self_type,
                            rhs_type: other_type,
                            expected_rhs_type: expected_other_type,
                        },
                        *loc,
                    ));
                }
            }
            _ => {
                // Handle [`CallInfo::IsNormalFunctionCall`] and other uninteresting variants
                // of [`CallInfo`] (e.g, `CallInfo::IsUnaryOp` and unsupported comparison operators)
                // Helper lambdas
                let mut type_check_arg = |param_name, expected_arg_ty, arg_ty| {
                    let ok = self.unify_impl(expected_arg_ty, arg_ty, false).is_ok();
                    if ok {
                        Ok(())
                    } else {
                        // Typecheck failed, throw an error.
                        self.restore_snapshot();
                        Err(TypeError::new(
                            TypeErrorKind::IncorrectArgType {
                                name: param_name,
                                expected: expected_arg_ty,
                                got: arg_ty,
                            },
                            *loc,
                        ))
                    }
                };
                // Check for "too many arguments"
                if !is_vararg && num_params < posargs.len() {
                    let expected_min_count =
                        signature.args.iter().filter(|param| param.is_required()).count();
                    let expected_max_count = num_params;
                    self.restore_snapshot();
                    return Err(TypeError::new(
                        TypeErrorKind::TooManyArguments {
                            expected_min_count,
                            expected_max_count,
                            got_count: num_args,
                        },
                        *loc,
                    ));
                }
                // NOTE: order of `param_info_by_name` is leveraged, so use an IndexMap
                let mut param_info_by_name: IndexMap<StrRef, ParamInfo> = signature
                    .args
                    .iter()
                    .map(|arg| (arg.name, ParamInfo { has_been_supplied: false, param: arg }))
                    .collect();
                // Now consume all positional arguments and typecheck them.
                for (&arg_ty, param) in zip(posargs, signature.args.iter()) {
                    // We will also use this opportunity to mark the corresponding `param_info` as having been supplied.
                    let param_info = param_info_by_name.get_mut(&param.name).unwrap();
                    param_info.has_been_supplied = true;
                    // Typecheck
                    type_check_arg(param.name, param.ty, arg_ty)?;
                }
                if is_vararg {
                    debug_assert!(!signature.args.is_empty());
                    let vararg_args = posargs.iter().skip(signature.args.len());
                    let vararg_param = signature.args.last().unwrap();
                    for (&arg_ty, param) in zip(vararg_args, repeat(vararg_param)) {
                        // `param_info` for this argument would've already been marked as supplied
                        // during non-vararg posarg typecheck
                        type_check_arg(param.name, param.ty, arg_ty)?;
                    }
                }
                // Now consume all keyword arguments and typecheck them.
                for (&param_name, &arg_ty) in kwargs {
                    // We will also use this opportunity to check if this keyword argument is "legal".
                    let Some(param_info) = param_info_by_name.get_mut(&param_name) else {
                        self.restore_snapshot();
                        return Err(TypeError::new(
                            TypeErrorKind::UnknownArgName(param_name),
                            *loc,
                        ));
                    };
                    if param_info.has_been_supplied {
                        // NOTE: Duplicate keyword argument (i.e., `hello(1, 2, 3, arg = 4, arg = 5)`)
                        // is IMPOSSIBLE as the parser would have already failed.
                        // We only have to care about "got multiple values for XYZ"
                        self.restore_snapshot();
                        return Err(TypeError::new(
                            TypeErrorKind::GotMultipleValues { name: param_name },
                            *loc,
                        ));
                    }
                    param_info.has_been_supplied = true;
                    // Typecheck
                    type_check_arg(param_name, param_info.param.ty, arg_ty)?;
                }
                // After checking posargs and kwargs, check if there are any
                // unsupplied required parameters, and throw an error if they exist.
                let missing_arg_names = param_info_by_name
                    .values()
                    .filter(|param_info| {
                        param_info.param.is_required() && !param_info.has_been_supplied
                    })
                    .map(|param_info| param_info.param.name)
                    .collect_vec();
                if !missing_arg_names.is_empty() {
                    self.restore_snapshot();
                    return Err(TypeError::new(
                        TypeErrorKind::MissingArgs { missing_arg_names },
                        *loc,
                    ));
                }
                // Finally, check the Call's return type
                self.unify_impl(*ret, signature.ret, false).map_err(|mut err| {
                    self.restore_snapshot();
                    if err.loc.is_none() {
@ -624,7 +849,10 @@ impl Unifier {
                    }
                    err
                })?;
-        *fun.borrow_mut() = Some(instantiated);
+            }
        }
        *fun.borrow_mut() = Some(b);
        self.discard_snapshot(snapshot);
        Ok(())
@ -755,7 +983,10 @@ impl Unifier {
                self.unify_impl(x, b, false)?;
                self.set_a_to_b(a, x);
            }
-            (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TTuple { ty }) => {
+            (
                TVar { fields: Some(fields), range, is_const_generic: false, .. },
                TTuple { ty, .. },
            ) => {
                let len = i32::try_from(ty.len()).unwrap();
                for (k, v) in fields {
                    match *k {
@ -776,31 +1007,25 @@ impl Unifier {
                            self.unify_impl(v.ty, ty[ind as usize], false)
                                .map_err(|e| e.at(v.loc))?;
                        }
-                        RecordKey::Str(_) => {
+                        RecordKey::Str(s) => {
-                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc))
+                            let tuple_fns = [
-                        }
+                                Cmpop::Eq.op_info().method_name,
-                    }
+                                Cmpop::NotEq.op_info().method_name,
-                }
+                            ];
                let x = self.check_var_compatibility(b, range)?.unwrap_or(b);
                self.unify_impl(x, b, false)?;
                self.set_a_to_b(a, x);
            }
            (TVar { fields: Some(fields), range, is_const_generic: false, .. }, TList { ty }) => {
                for (k, v) in fields {
                    match *k {
                        RecordKey::Int(_) => {
                            self.unify_impl(v.ty, *ty, false).map_err(|e| e.at(v.loc))?;
                        }
                        RecordKey::Str(_) => {
                            return Err(TypeError::new(TypeErrorKind::NoSuchField(*k, b), v.loc))
                        }
                    }
                }
                let x = self.check_var_compatibility(b, range)?.unwrap_or(b);
                self.unify_impl(x, b, false)?;
                self.set_a_to_b(a, x);
            }
                            if !tuple_fns.into_iter().any(|op| s.to_string() == op) {
                                return Err(TypeError::new(
                                    TypeErrorKind::NoSuchField(*k, b),
                                    v.loc,
                                ));
                            }
                        }
                    }
                }
                let x = self.check_var_compatibility(b, range)?.unwrap_or(b);
                self.unify_impl(x, b, false)?;
                self.set_a_to_b(a, x);
            }
            (
                TVar { id: id1, range: ty1, is_const_generic: true, .. },
                TVar { id: id2, range: ty2, .. },
@ -868,24 +1093,50 @@ impl Unifier {
                self.set_a_to_b(a, b);
            }
-            (TTuple { ty: ty1 }, TTuple { ty: ty2 }) => {
+            (
-                if ty1.len() != ty2.len() {
+                TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
-                    return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
+                TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
            ) => {
                // Rules for Tuples:
                // - ty1: is_vararg && ty2: is_vararg -> ty1[0] == ty2[0]
                // - ty1: is_vararg && ty2: !is_vararg -> type error (not enough info to infer the correct number of arguments)
                // - ty1: !is_vararg && ty2: is_vararg -> ty1[..] == ty2[0]
                // - ty1: !is_vararg && ty2: !is_vararg -> ty1.len() == ty2.len() && ty1[i] == ty2[i]
                debug_assert!(!is_vararg1 || ty1.len() == 1);
                debug_assert!(!is_vararg2 || ty2.len() == 1);
                match (*is_vararg1, *is_vararg2) {
                    (true, true) => {
                        if self.unify_impl(ty1[0], ty2[0], false).is_err() {
                            return Self::incompatible_types(a, b);
                        }
                    }
                    (true, false) => return Self::incompatible_types(a, b),
                    (false, true) => {
                        for y in ty2 {
                            if self.unify_impl(ty1[0], *y, false).is_err() {
                                return Self::incompatible_types(a, b);
                            }
                        }
                    }
                    (false, false) => {
                        if ty1.len() != ty2.len() {
                            return Self::incompatible_types(a, b);
                        }
                        for (x, y) in ty1.iter().zip(ty2.iter()) {
                            if self.unify_impl(*x, *y, false).is_err() {
-                        return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
+                                return Self::incompatible_types(a, b);
                            }
                        }
                    }
                }
                self.set_a_to_b(a, b);
            }
-            (TList { ty: ty1 }, TList { ty: ty2 }) => {
+            (TVar { fields: Some(map), range, .. }, TObj { obj_id, fields, params }) => {
                if self.unify_impl(*ty1, *ty2, false).is_err() {
                    return Err(TypeError::new(TypeErrorKind::IncompatibleTypes(a, b), None));
                }
                self.set_a_to_b(a, b);
            }
            (TVar { fields: Some(map), range, .. }, TObj { fields, .. }) => {
                for (k, field) in map {
                    match *k {
                        RecordKey::Str(s) => {
@ -904,10 +1155,18 @@ impl Unifier {
                            self.unify_impl(field.ty, ty, false).map_err(|v| v.at(field.loc))?;
                        }
                        RecordKey::Int(_) => {
                            // Allow expressions such as list[0]
                            if *obj_id == PrimDef::List.id() {
                                let ty = iter_type_vars(params).nth(0).unwrap().ty;
                                self.unify_impl(field.ty, ty, false)
                                    .map_err(|e| e.at(field.loc))?;
                            } else {
                                return Err(TypeError::new(
                                    TypeErrorKind::NoSuchField(*k, b),
                                    field.loc,
-                            ))
+                                ));
                            }
                        }
                    }
                }
@ -990,17 +1249,10 @@ impl Unifier {
                self.unification_table.set_value(b, Rc::new(TCall(calls)));
            }
            (TCall(calls), TFunc(signature)) => {
                let required: Vec<StrRef> = signature
                    .args
                    .iter()
                    .filter(|v| v.default_value.is_none())
                    .map(|v| v.name)
                    .rev()
                    .collect();
                // we unify every calls to the function signature.
                for c in calls {
                    let call = self.calls[c.0].clone();
-                    self.unify_call(&call, b, signature, &required)?;
+                    self.unify_call(&call, b, signature)?;
                }
                self.set_a_to_b(a, b);
            }
@ -1124,13 +1376,22 @@ impl Unifier {
            TypeEnum::TLiteral { values, .. } => {
                format!("const({})", values.iter().map(|v| format!("{v:?}")).join(", "))
            }
-            TypeEnum::TTuple { ty } => {
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
-                let mut fields =
+                if *is_vararg_ctx {
-                    ty.iter().map(|v| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
+                    debug_assert_eq!(ty.len(), 1);
                    let field = self.internal_stringify(
                        *ty.iter().next().unwrap(),
                        obj_to_name,
                        var_to_name,
                        notes,
                    );
                    format!("tuple[*{field}]")
                } else {
                    let mut fields = ty
                        .iter()
                        .map(|v| self.internal_stringify(*v, obj_to_name, var_to_name, notes));
                    format!("tuple[{}]", fields.join(", "))
                }
            TypeEnum::TList { ty } => {
                format!("list[{}]", self.internal_stringify(*ty, obj_to_name, var_to_name, notes))
            }
            TypeEnum::TVirtual { ty } => {
                format!(
@ -1155,17 +1416,21 @@ impl Unifier {
                    .args
                    .iter()
                    .map(|arg| {
                        let vararg_prefix = if arg.is_vararg { "*" } else { "" };
                        if let Some(dv) = &arg.default_value {
                            format!(
-                                "{}:{}={}",
+                                "{}:{}{}={}",
                                arg.name,
                                vararg_prefix,
                                self.internal_stringify(arg.ty, obj_to_name, var_to_name, notes),
                                dv
                            )
                        } else {
                            format!(
-                                "{}:{}",
+                                "{}:{}{}",
                                arg.name,
                                vararg_prefix,
                                self.internal_stringify(arg.ty, obj_to_name, var_to_name, notes)
                            )
                        }
@ -1251,7 +1516,7 @@ impl Unifier {
        match &*ty {
            TypeEnum::TRigidVar { .. } | TypeEnum::TLiteral { .. } => None,
            TypeEnum::TVar { id, .. } => mapping.get(id).copied(),
-            TypeEnum::TTuple { ty } => {
+            TypeEnum::TTuple { ty, is_vararg_ctx } => {
                let mut new_ty = Cow::from(ty);
                for (i, t) in ty.iter().enumerate() {
                    if let Some(t1) = self.subst_impl(*t, mapping, cache) {
@ -1259,14 +1524,14 @@ impl Unifier {
                    }
                }
                if matches!(new_ty, Cow::Owned(_)) {
-                    Some(self.add_ty(TypeEnum::TTuple { ty: new_ty.into_owned() }))
+                    Some(self.add_ty(TypeEnum::TTuple {
                        ty: new_ty.into_owned(),
                        is_vararg_ctx: *is_vararg_ctx,
                    }))
                } else {
                    None
                }
            }
            TypeEnum::TList { ty } => {
                self.subst_impl(*ty, mapping, cache).map(|t| self.add_ty(TypeEnum::TList { ty: t }))
            }
            TypeEnum::TVirtual { ty } => self
                .subst_impl(*ty, mapping, cache)
                .map(|t| self.add_ty(TypeEnum::TVirtual { ty: t })),
@ -1277,6 +1542,7 @@ impl Unifier {
                // This is also used to prevent infinite substitution...
                let need_subst = params.values().any(|v| {
                    let ty = self.unification_table.probe_value(*v);
                    // TODO(Derppening): #444
                    if let TypeEnum::TVar { id, .. } = ty.as_ref() {
                        mapping.contains_key(id)
                    } else {
@ -1421,20 +1687,55 @@ impl Unifier {
                }
            }
            (TVar { range, .. }, _) => self.check_var_compatibility(b, range).or(Err(())),
-            (TTuple { ty: ty1 }, TTuple { ty: ty2 }) if ty1.len() == ty2.len() => {
+            (
-                let ty: Vec<_> = zip(ty1.iter(), ty2.iter())
+                TTuple { ty: ty1, is_vararg_ctx: is_vararg1 },
-                    .map(|(a, b)| self.get_intersection(*a, *b))
+                TTuple { ty: ty2, is_vararg_ctx: is_vararg2 },
-                    .try_collect()?;
+            ) => {
-                if ty.iter().any(Option::is_some) {
+                if *is_vararg1 && *is_vararg2 {
-                    Ok(Some(self.add_ty(TTuple {
+                    let isect_ty = self.get_intersection(ty1[0], ty2[0])?;
-                        ty: zip(ty, ty1.iter()).map(|(a, b)| a.unwrap_or(*b)).collect(),
+                    Ok(isect_ty.map(|ty| self.add_ty(TTuple { ty: vec![ty], is_vararg_ctx: true })))
                    })))
                } else {
-                    Ok(None)
+                    let zip_iter: Box<dyn Iterator<Item = (&Type, &Type)>> =
                        match (*is_vararg1, *is_vararg2) {
                            (true, _) => Box::new(repeat_n(&ty1[0], ty2.len()).zip(ty2.iter())),
                            (_, false) => Box::new(ty1.iter().zip(repeat_n(&ty2[0], ty1.len()))),
                            _ => {
                                if ty1.len() != ty2.len() {
                                    return Err(());
                                }
                                Box::new(ty1.iter().zip(ty2.iter()))
                            }
                        };
                    let ty: Vec<_> =
                        zip_iter.map(|(a, b)| self.get_intersection(*a, *b)).try_collect()?;
                    Ok(if ty.iter().any(Option::is_some) {
                        Some(self.add_ty(TTuple {
                            ty: zip(ty, ty1.iter()).map(|(a, b)| a.unwrap_or(*b)).collect(),
                            is_vararg_ctx: false,
                        }))
                    } else {
                        None
                    })
                }
            }
-            (TList { ty: ty1 }, TList { ty: ty2 }) => {
+            // TODO(Derppening): #444
-                Ok(self.get_intersection(*ty1, *ty2)?.map(|ty| self.add_ty(TList { ty })))
+            (
                TObj { obj_id: id1, fields, params: params1 },
                TObj { obj_id: id2, params: params2, .. },
            ) if *id1 == PrimDef::List.id() && *id2 == PrimDef::List.id() => {
                let tv_id = iter_type_vars(params1).nth(0).unwrap().id;
                let ty1 = iter_type_vars(params1).nth(0).unwrap().ty;
                let ty2 = iter_type_vars(params2).nth(0).unwrap().ty;
                Ok(self.get_intersection(ty1, ty2)?.map(|ty| {
                    self.add_ty(TObj {
                        obj_id: *id1,
                        fields: fields.clone(),
                        params: into_var_map([TypeVar { id: tv_id, ty }]),
                    })
                }))
            }
            (TVirtual { ty: ty1 }, TVirtual { ty: ty2 }) => {
                Ok(self.get_intersection(*ty1, *ty2)?.map(|ty| self.add_ty(TVirtual { ty })))
--- a/nac3core/src/typecheck/typedef/test.rs
+++ b/nac3core/src/typecheck/typedef/test.rs
@ -28,14 +28,14 @@ impl Unifier {
                TypeEnum::TVar { fields: Some(map1), .. },
                TypeEnum::TVar { fields: Some(map2), .. },
            ) => self.map_eq2(map1, map2),
-            (TypeEnum::TTuple { ty: ty1 }, TypeEnum::TTuple { ty: ty2 }) => {
+            (
                TypeEnum::TTuple { ty: ty1, is_vararg_ctx: false },
                TypeEnum::TTuple { ty: ty2, is_vararg_ctx: false },
            ) => {
                ty1.len() == ty2.len()
                    && ty1.iter().zip(ty2.iter()).all(|(t1, t2)| self.eq(*t1, *t2))
            }
-            (TypeEnum::TList { ty: ty1 }, TypeEnum::TList { ty: ty2 })
+            (TypeEnum::TVirtual { ty: ty1 }, TypeEnum::TVirtual { ty: ty2 }) => self.eq(*ty1, *ty2),
            | (TypeEnum::TVirtual { ty: ty1 }, TypeEnum::TVirtual { ty: ty2 }) => {
                self.eq(*ty1, *ty2)
            }
            (
                TypeEnum::TObj { obj_id: id1, params: params1, .. },
                TypeEnum::TObj { obj_id: id2, params: params2, .. },
@ -119,6 +119,15 @@ impl TestEnvironment {
                params: into_var_map([tvar]),
            }),
        );
        let tvar = unifier.get_dummy_var();
        type_mapping.insert(
            "list".into(),
            unifier.add_ty(TypeEnum::TObj {
                obj_id: PrimDef::List.id(),
                fields: HashMap::new(),
                params: into_var_map([tvar]),
            }),
        );
        TestEnvironment { unifier, type_mapping }
    }
@ -133,6 +142,36 @@ impl TestEnvironment {
        // for testing only, so we can just panic when the input is malformed
        let end = typ.find(|c| ['[', ',', ']', '='].contains(&c)).unwrap_or(typ.len());
        match &typ[..end] {
            "list" => {
                let mut s = &typ[end..];
                assert_eq!(&s[0..1], "[");
                let mut ty = Vec::new();
                while &s[0..1] != "]" {
                    let result = self.internal_parse(&s[1..], mapping);
                    ty.push(result.0);
                    s = result.1;
                }
                assert_eq!(ty.len(), 1);
                let list_elem_tvar = if let TypeEnum::TObj { params, .. } =
                    &*self.unifier.get_ty_immutable(self.type_mapping["list"])
                {
                    iter_type_vars(params).next().unwrap()
                } else {
                    unreachable!()
                };
                (
                    self.unifier
                        .subst(
                            self.type_mapping["list"],
                            &into_var_map([TypeVar { id: list_elem_tvar.id, ty: ty[0] }]),
                        )
                        .unwrap(),
                    &s[1..],
                )
            }
            "tuple" => {
                let mut s = &typ[end..];
                assert_eq!(&s[0..1], "[");
@ -142,13 +181,7 @@ impl TestEnvironment {
                    ty.push(result.0);
                    s = result.1;
                }
-                (self.unifier.add_ty(TypeEnum::TTuple { ty }), &s[1..])
+                (self.unifier.add_ty(TypeEnum::TTuple { ty, is_vararg_ctx: false }), &s[1..])
            }
            "list" => {
                assert_eq!(&typ[end..=end], "[");
                let (ty, s) = self.internal_parse(&typ[end + 1..], mapping);
                assert_eq!(&s[0..1], "]");
                (self.unifier.add_ty(TypeEnum::TList { ty }), &s[1..])
            }
            "Record" => {
                let mut s = &typ[end..];
@ -274,7 +307,7 @@ fn test_unify(
        ("v1", "tuple[int]"),
        ("v2", "list[int]"),
    ],
-    (("v1", "v2"), "Incompatible types: list[0] and tuple[0]")
+    (("v1", "v2"), "Incompatible types: 11[0] and tuple[0]")
    ; "type mismatch"
 )]
 #[test_case(2,
@ -298,7 +331,7 @@ fn test_unify(
        ("v1", "Record[a=float,b=int]"),
        ("v2", "Foo[v3]"),
    ],
-    (("v1", "v2"), "`3[typevar4]::b` field/method does not exist")
+    (("v1", "v2"), "`3[typevar5]::b` field/method does not exist")
    ; "record obj merge"
 )]
 /// Test cases for invalid unifications.
@ -388,6 +421,14 @@ fn test_typevar_range() {
    let int_list = env.parse("list[int]", &HashMap::new());
    let float_list = env.parse("list[float]", &HashMap::new());
    let list_elem_tvar = if let TypeEnum::TObj { params, .. } =
        &*env.unifier.get_ty_immutable(env.type_mapping["list"])
    {
        iter_type_vars(params).next().unwrap()
    } else {
        unreachable!()
    };
    // unification between v and int
    // where v in (int, bool)
    let v = env.unifier.get_fresh_var_with_range(&[int, boolean], None, None).ty;
@ -398,7 +439,7 @@ fn test_typevar_range() {
    let v = env.unifier.get_fresh_var_with_range(&[int, boolean], None, None).ty;
    assert_eq!(
        env.unify(int_list, v),
-        Err("Expected any one of these types: 0, 2, but got list[0]".to_string())
+        Err("Expected any one of these types: 0, 2, but got 11[0]".to_string())
    );
    // unification between v and float
@ -410,7 +451,11 @@ fn test_typevar_range() {
    );
    let v1 = env.unifier.get_fresh_var_with_range(&[int, boolean], None, None).ty;
-    let v1_list = env.unifier.add_ty(TypeEnum::TList { ty: v1 });
+    let v1_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: v1 }]),
    });
    let v = env.unifier.get_fresh_var_with_range(&[int, v1_list], None, None).ty;
    // unification between v and int
    // where v in (int, list[v1]), v1 in (int, bool)
@ -424,9 +469,10 @@ fn test_typevar_range() {
    let v = env.unifier.get_fresh_var_with_range(&[int, v1_list], None, None).ty;
    // unification between v and list[float]
    // where v in (int, list[v1]), v1 in (int, bool)
    println!("float_list: {}, v: {}", env.unifier.stringify(float_list), env.unifier.stringify(v));
    assert_eq!(
        env.unify(float_list, v),
-        Err("Expected any one of these types: 0, list[typevar5], but got list[1]\n\nNotes:\n    typevar5 ∈ {0, 2}".to_string())
+        Err("Expected any one of these types: 0, 11[typevar6], but got 11[1]\n\nNotes:\n    typevar6 ∈ {0, 2}".to_string())
    );
    let a = env.unifier.get_fresh_var_with_range(&[int, float], None, None).ty;
@ -441,34 +487,66 @@ fn test_typevar_range() {
    let a = env.unifier.get_fresh_var_with_range(&[int, float], None, None).ty;
    let b = env.unifier.get_fresh_var_with_range(&[boolean, float], None, None).ty;
-    let a_list = env.unifier.add_ty(TypeEnum::TList { ty: a });
+    let a_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: a }]),
    });
    let a_list = env.unifier.get_fresh_var_with_range(&[a_list], None, None).ty;
-    let b_list = env.unifier.add_ty(TypeEnum::TList { ty: b });
+    let b_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: b }]),
    });
    let b_list = env.unifier.get_fresh_var_with_range(&[b_list], None, None).ty;
    env.unifier.unify(a_list, b_list).unwrap();
-    let float_list = env.unifier.add_ty(TypeEnum::TList { ty: float });
+    let float_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: float }]),
    });
    env.unifier.unify(a_list, float_list).unwrap();
    // previous unifications should not affect a and b
    env.unifier.unify(a, int).unwrap();
    let a = env.unifier.get_fresh_var_with_range(&[int, float], None, None).ty;
    let b = env.unifier.get_fresh_var_with_range(&[boolean, float], None, None).ty;
-    let a_list = env.unifier.add_ty(TypeEnum::TList { ty: a });
+    let a_list = env.unifier.add_ty(TypeEnum::TObj {
-    let b_list = env.unifier.add_ty(TypeEnum::TList { ty: b });
+        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: a }]),
    });
    let b_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: b }]),
    });
    env.unifier.unify(a_list, b_list).unwrap();
-    let int_list = env.unifier.add_ty(TypeEnum::TList { ty: int });
+    let int_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: int }]),
    });
    assert_eq!(
        env.unify(a_list, int_list),
-        Err("Incompatible types: list[typevar22] and list[0]\
+        Err("Incompatible types: 11[typevar23] and 11[0]\
-            \n\nNotes:\n    typevar22 ∈ {1}"
+            \n\nNotes:\n    typevar23 ∈ {1}"
            .into())
    );
    let a = env.unifier.get_fresh_var_with_range(&[int, float], None, None).ty;
    let b = env.unifier.get_dummy_var().ty;
-    let a_list = env.unifier.add_ty(TypeEnum::TList { ty: a });
+    let a_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: a }]),
    });
    let a_list = env.unifier.get_fresh_var_with_range(&[a_list], None, None).ty;
-    let b_list = env.unifier.add_ty(TypeEnum::TList { ty: b });
+    let b_list = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: b }]),
    });
    env.unifier.unify(a_list, b_list).unwrap();
    assert_eq!(
        env.unify(b, boolean),
@ -482,16 +560,25 @@ fn test_rigid_var() {
    let a = env.unifier.get_fresh_rigid_var(None, None).ty;
    let b = env.unifier.get_fresh_rigid_var(None, None).ty;
    let x = env.unifier.get_dummy_var().ty;
-    let list_a = env.unifier.add_ty(TypeEnum::TList { ty: a });
+    let list_elem_tvar = env.unifier.get_fresh_var(Some("list_elem".into()), None);
-    let list_x = env.unifier.add_ty(TypeEnum::TList { ty: x });
+    let list_a = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: a }]),
    });
    let list_x = env.unifier.add_ty(TypeEnum::TObj {
        obj_id: env.type_mapping["list"].obj_id(&env.unifier).unwrap(),
        fields: Mapping::default(),
        params: into_var_map([TypeVar { id: list_elem_tvar.id, ty: x }]),
    });
    let int = env.parse("int", &HashMap::new());
    let list_int = env.parse("list[int]", &HashMap::new());
-    assert_eq!(env.unify(a, b), Err("Incompatible types: typevar3 and typevar2".to_string()));
+    assert_eq!(env.unify(a, b), Err("Incompatible types: typevar4 and typevar3".to_string()));
    env.unifier.unify(list_a, list_x).unwrap();
    assert_eq!(
        env.unify(list_x, list_int),
-        Err("Incompatible types: list[typevar2] and list[0]".to_string())
+        Err("Incompatible types: 11[typevar3] and 11[0]".to_string())
    );
    env.unifier.replace_rigid_var(a, int);
@ -506,14 +593,25 @@ fn test_instantiation() {
    let float = env.parse("float", &HashMap::new());
    let list_int = env.parse("list[int]", &HashMap::new());
-    let obj_map: HashMap<_, _> = [(0usize, "int"), (1, "float"), (2, "bool")].into();
+    let list_elem_tvar = if let TypeEnum::TObj { params, .. } =
        &*env.unifier.get_ty_immutable(env.type_mapping["list"])
    {
        iter_type_vars(params).next().unwrap()
    } else {
        unreachable!()
    };
    let obj_map: HashMap<_, _> = [(0usize, "int"), (1, "float"), (2, "bool"), (11, "list")].into();
    let v = env.unifier.get_fresh_var_with_range(&[int, boolean], None, None).ty;
-    let list_v = env.unifier.add_ty(TypeEnum::TList { ty: v });
+    let list_v = env
        .unifier
        .subst(env.type_mapping["list"], &into_var_map([TypeVar { id: list_elem_tvar.id, ty: v }]))
        .unwrap();
    let v1 = env.unifier.get_fresh_var_with_range(&[list_v, int], None, None).ty;
    let v2 = env.unifier.get_fresh_var_with_range(&[list_int, float], None, None).ty;
    let t = env.unifier.get_dummy_var().ty;
-    let tuple = env.unifier.add_ty(TypeEnum::TTuple { ty: vec![v, v1, v2] });
+    let tuple = env.unifier.add_ty(TypeEnum::TTuple { ty: vec![v, v1, v2], is_vararg_ctx: false });
    let v3 = env.unifier.get_fresh_var_with_range(&[tuple, t], None, None).ty;
    // t = TypeVar('t')
    // v = TypeVar('v', int, bool)
@ -536,7 +634,7 @@ fn test_instantiation() {
        tuple[int, list[bool], list[int]]
        tuple[int, list[int], float]
        tuple[int, list[int], list[int]]
-        v5"
+        v6"
    }
    .split('\n')
    .collect_vec();
--- a/nac3ld/src/dwarf.rs
+++ b/nac3ld/src/dwarf.rs
@ -238,7 +238,7 @@ impl<'a> EH_Frame<'a> {
 /// From the [specification](https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html):
 ///
 /// > Each CFI record contains a Common Information Entry (CIE) record followed by 1 or more Frame
-/// Description Entry (FDE) records.
+/// > Description Entry (FDE) records.
 pub struct CFI_Record<'a> {
    // It refers to the augmentation data that corresponds to 'R' in the augmentation string
    fde_pointer_encoding: u8,
--- a/nac3parser/Cargo.toml
+++ b/nac3parser/Cargo.toml
@ -8,11 +8,11 @@ license = "MIT"
 edition = "2021"
 [build-dependencies]
-lalrpop = "0.20"
+lalrpop = "0.21"
 [dependencies]
 nac3ast = { path = "../nac3ast" }
-lalrpop-util = "0.20"
+lalrpop-util = "0.21"
 log = "0.4"
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
--- a/nac3standalone/Cargo.toml
+++ b/nac3standalone/Cargo.toml
@ -4,16 +4,13 @@ version = "0.1.0"
 authors = ["M-Labs"]
 edition = "2021"
 [features]
 no-escape-analysis = ["nac3core/no-escape-analysis"]
 [dependencies]
 parking_lot = "0.12"
 nac3parser = { path = "../nac3parser" }
 nac3core = { path = "../nac3core" }
 [dependencies.clap]
 version = "4.5"
 features = ["derive"]
 [dependencies.inkwell]
 version = "0.4"
 default-features = false
 features = ["llvm14-0", "target-x86", "target-arm", "target-riscv", "no-libffi-linking"]
--- a/nac3standalone/demo/check_demo.sh
+++ b/nac3standalone/demo/check_demo.sh
@ -3,23 +3,66 @@
 set -e
 if [ -z "$1" ]; then
-  echo "Requires at least one argument"
+    echo "No argument supplied"
    exit 1
 fi
 declare -a nac3args
 while [ $# -gt 1 ]; do
  case "$1" in
    --help)
      echo "Usage: check_demo.sh [--debug] [-i686] -- [NAC3ARGS...] demo"
      exit
      ;;
    --debug)
      debug=1
      ;;
    -i686)
      i686=1
      ;;
    --)
      shift
      break
      ;;
    *)
      echo "Unrecognized argument \"$1\""
      exit 1
      ;;
  esac
  shift
 done
 while [ $# -gt 1 ]; do
  nac3args+=("$1")
  shift
 done
 demo="$1"
 echo -n "Checking $demo... "
 ./interpret_demo.py "$demo" > interpreted.log
 ./run_demo.sh --out run.log "${nac3args[@]}" "$demo"
 ./run_demo.sh --lli --out run_lli.log "${nac3args[@]}" "$demo"
 diff -Nau interpreted.log run.log
 diff -Nau interpreted.log run_lli.log
 echo "ok"
-rm -f interpreted.log run.log run_lli.log
+echo "### Checking $demo..."
 echo ">>>>>> Running $demo with the Python interpreter"
 ./interpret_demo.py "$demo" > interpreted.log
 if [ -n "$i686" ]; then
  echo "...... Trying NAC3's 32-bit code generator output"
  if [ -n "$debug" ]; then
    ./run_demo.sh --debug -i686 --out run_32.log -- "${nac3args[@]}" "$demo"
  else
    ./run_demo.sh -i686 --out run_32.log -- "${nac3args[@]}" "$demo"
  fi
  diff -Nau interpreted.log run_32.log
 fi
 echo "...... Trying NAC3's 64-bit code generator output"
 if [ -n "$debug" ]; then
  ./run_demo.sh --debug --out run_64.log -- "${nac3args[@]}" "$demo"
 else
  ./run_demo.sh --out run_64.log -- "${nac3args[@]}" "$demo"
 fi
 diff -Nau interpreted.log run_64.log
 echo "...... OK"
 rm -f interpreted.log \
  run_32.log run_64.log
--- a/nac3standalone/demo/check_demos.sh
+++ b/nac3standalone/demo/check_demos.sh
@ -2,6 +2,11 @@
 set -e
 if [ "$1" == "--help" ]; then
    echo "Usage: check_demos.sh [CHECKARGS...] [--] [NAC3ARGS...]"
    exit
 fi
 count=0
 for demo in src/*.py; do
  ./check_demo.sh "$@" "$demo"
--- a/nac3standalone/demo/demo.c
+++ b/nac3standalone/demo/demo.c
@ -6,8 +6,6 @@
 #include <stdlib.h>
 #include <string.h>
 #define usize size_t
 double dbl_nan(void) {
    return NAN;
 }
@ -44,6 +42,15 @@ void output_float64(double x) {
    }
 }
 void output_range(int32_t range[3]) {
    printf("range(");
    printf("%d, %d", range[0], range[1]);
    if (range[2] != 1) {
        printf(", %d", range[2]);
    }
    puts(")");
 }
 void output_asciiart(int32_t x) {
    static const char* chars = " .,-:;i+hHM$*#@    ";
    if (x < 0) {
@ -55,14 +62,14 @@ void output_asciiart(int32_t x) {
 struct cslice {
    void* data;
-    usize len;
+    size_t len;
 };
 void output_int32_list(struct cslice* slice) {
    const int32_t* data = (int32_t*)slice->data;
    putchar('[');
-    for (usize i = 0; i < slice->len; ++i) {
+    for (size_t i = 0; i < slice->len; ++i) {
        if (i == slice->len - 1) {
            printf("%d", data[i]);
        } else {
@ -76,9 +83,13 @@ void output_int32_list(struct cslice *slice) {
 void output_str(struct cslice* slice) {
    const char* data = (const char*)slice->data;
-    for (usize i = 0; i < slice->len; ++i) {
+    for (size_t i = 0; i < slice->len; ++i) {
        putchar(data[i]);
    }
 }
 void output_strln(struct cslice* slice) {
    output_str(slice);
    putchar('\n');
 }
@ -94,8 +105,26 @@ uint32_t __nac3_personality(uint32_t state, uint32_t exception_object, uint32_t
    __builtin_unreachable();
 }
-uint32_t __nac3_raise(uint32_t state, uint32_t exception_object, uint32_t context) {
+// See `struct Exception<'a>` in
-    printf("__nac3_raise(state: %u, exception_object: %u, context: %u)\n", state, exception_object, context);
+// https://github.com/m-labs/artiq/blob/master/artiq/firmware/libeh/eh_artiq.rs
 struct Exception {
    uint32_t id;
    struct cslice file;
    uint32_t line;
    uint32_t column;
    struct cslice function;
    struct cslice message;
    int64_t param[3];
 };
 uint32_t __nac3_raise(struct Exception* e) {
    printf("__nac3_raise called. Exception details:\n");
    printf("          ID: %" PRIu32 "\n", e->id);
    printf("    Location: %*s:%" PRIu32 ":%" PRIu32 "\n", (int)e->file.len, (const char*)e->file.data, e->line,
           e->column);
    printf("    Function: %*s\n", (int)e->function.len, (const char*)e->function.data);
    printf("     Message: \"%*s\"\n", (int)e->message.len, (const char*)e->message.data);
    printf("      Params: {0}=%" PRId64 ", {1}=%" PRId64 ", {2}=%" PRId64 "\n", e->param[0], e->param[1], e->param[2]);
    exit(101);
    __builtin_unreachable();
 }
--- a/nac3standalone/demo/interpret_demo.py
+++ b/nac3standalone/demo/interpret_demo.py
@ -6,6 +6,7 @@ import importlib.machinery
 import math
 import numpy as np
 import numpy.typing as npt
 import scipy as sp
 import pathlib
 from numpy import int32, int64, uint32, uint64
@ -107,6 +108,9 @@ def patch(module):
    def output_float(x):
        print("%f" % x)
    def output_strln(x):
        print(x, end='')
    def dbg_stack_address(_):
        return 0
@ -120,6 +124,8 @@ def patch(module):
            return output_asciiart
        elif name == "output_float64":
            return output_float
        elif name == "output_str":
            return output_strln
        elif name in {
            "output_bool",
            "output_int32",
@ -127,7 +133,8 @@ def patch(module):
            "output_int32_list",
            "output_uint32",
            "output_uint64",
-            "output_str",
+            "output_strln",
            "output_range",
        }:
            return print
        elif name == "dbg_stack_address":
@ -161,7 +168,7 @@ def patch(module):
    module.ceil64 = _ceil
    module.np_ceil = np.ceil
-    # NumPy ndarray functions
+    # NumPy NDArray factory functions
    module.ndarray = NDArray
    module.np_ndarray = np.ndarray
    module.np_empty = np.empty
@ -177,8 +184,10 @@ def patch(module):
    module.np_isinf = np.isinf
    module.np_min = np.min
    module.np_minimum = np.minimum
    module.np_argmin = np.argmin
    module.np_max = np.max
    module.np_maximum = np.maximum
    module.np_argmax = np.argmax
    module.np_sin = np.sin
    module.np_cos = np.cos
    module.np_exp = np.exp
@ -209,8 +218,10 @@ def patch(module):
    module.np_ldexp = np.ldexp
    module.np_hypot = np.hypot
    module.np_nextafter = np.nextafter
    module.np_transpose = np.transpose
    module.np_reshape = np.reshape
-    # SciPy Math Functions
+    # SciPy Math functions
    module.sp_spec_erf = special.erf
    module.sp_spec_erfc = special.erfc
    module.sp_spec_gamma = special.gamma
@ -218,16 +229,19 @@ def patch(module):
    module.sp_spec_j0 = special.j0
    module.sp_spec_j1 = special.j1
-    # NumPy NDArray Functions
+    # Linalg functions
-    module.np_ndarray = np.ndarray
+    module.np_dot = np.dot
-    module.np_empty = np.empty
+    module.np_linalg_cholesky = np.linalg.cholesky
-    module.np_zeros = np.zeros
+    module.np_linalg_qr = np.linalg.qr
-    module.np_ones = np.ones
+    module.np_linalg_svd = np.linalg.svd
-    module.np_full = np.full
+    module.np_linalg_inv = np.linalg.inv
-    module.np_eye = np.eye
+    module.np_linalg_pinv = np.linalg.pinv
-    module.np_identity = np.identity
+    module.np_linalg_matrix_power = np.linalg.matrix_power
-    module.np_any = np.any
+    module.np_linalg_det = np.linalg.det
-    module.np_all = np.all
+    
    module.sp_linalg_lu = lambda x: sp.linalg.lu(x, True)
    module.sp_linalg_schur = sp.linalg.schur
    module.sp_linalg_hessenberg = lambda x: sp.linalg.hessenberg(x, True)
 def file_import(filename, prefix="file_import_"):
    filename = pathlib.Path(filename)
--- a/nac3standalone/demo/linalg/Cargo.lock
+++ b/nac3standalone/demo/linalg/Cargo.lock
@ -0,0 +1,114 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 [[package]]
 name = "approx"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "autocfg"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 [[package]]
 name = "cslice"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f8cb7306107e4b10e64994de6d3274bd08996a7c1322a27b86482392f96be0a"
 [[package]]
 name = "libm"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 [[package]]
 name = "linalg"
 version = "0.1.0"
 dependencies = [
 "cslice",
 "nalgebra",
 ]
 [[package]]
 name = "nalgebra"
 version = "0.32.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b5c17de023a86f59ed79891b2e5d5a94c705dbe904a5b5c9c952ea6221b03e4"
 dependencies = [
 "approx",
 "num-complex",
 "num-rational",
 "num-traits",
 "simba",
 "typenum",
 ]
 [[package]]
 name = "num-complex"
 version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "num-integer"
 version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "num-rational"
 version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
 dependencies = [
 "num-integer",
 "num-traits",
 ]
 [[package]]
 name = "num-traits"
 version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
 "autocfg",
 "libm",
 ]
 [[package]]
 name = "paste"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 [[package]]
 name = "simba"
 version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
 dependencies = [
 "approx",
 "num-complex",
 "num-traits",
 "paste",
 ]
 [[package]]
 name = "typenum"
 version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
--- a/nac3standalone/demo/linalg/Cargo.toml
+++ b/nac3standalone/demo/linalg/Cargo.toml
@ -0,0 +1,13 @@
 [package]
 name = "linalg"
 version = "0.1.0"
 edition = "2021"
 [lib]
 crate-type = ["staticlib"]
 [dependencies]
 nalgebra = {version = "0.32.6", default-features = false, features = ["libm", "alloc"]}
 cslice = "0.3.0"
 [workspace]
--- a/nac3standalone/demo/linalg/src/lib.rs
+++ b/nac3standalone/demo/linalg/src/lib.rs
@ -0,0 +1,406 @@
 // Uses `nalgebra` crate to invoke `np_linalg` and `sp_linalg` functions
 // When converting between `nalgebra::Matrix` and `NDArray` following considerations are necessary
 //
 // * Both `nalgebra::Matrix` and `NDArray` require their content to be stored in row-major order
 // * `NDArray` data pointer can be directly read and converted to `nalgebra::Matrix` (row and column number must be known)
 // * `nalgebra::Matrix::as_slice` returns the content of matrix in column-major order and initial data needs to be transposed before storing it in `NDArray` data pointer
 use core::slice;
 use nalgebra::DMatrix;
 fn report_error(
    error_name: &str,
    fn_name: &str,
    file_name: &str,
    line_num: u32,
    col_num: u32,
    err_msg: &str,
 ) -> ! {
    panic!(
        "Exception {} from {} in {}:{}:{}, message: {}",
        error_name, fn_name, file_name, line_num, col_num, err_msg
    );
 }
 pub struct InputMatrix {
    pub ndims: usize,
    pub dims: *const usize,
    pub data: *mut f64,
 }
 impl InputMatrix {
    fn get_dims(&mut self) -> Vec<usize> {
        let dims = unsafe { slice::from_raw_parts(self.dims, self.ndims) };
        dims.to_vec()
    }
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_cholesky(mat1: *mut InputMatrix, out: *mut InputMatrix) {
    let mat1 = mat1.as_mut().unwrap();
    let out = out.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    if dim1[0] != dim1[1] {
        let err_msg =
            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
        report_error("LinAlgError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
    }
    let outdim = out.get_dims();
    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let result = matrix1.cholesky();
    match result {
        Some(res) => {
            out_slice.copy_from_slice(res.unpack().transpose().as_slice());
        }
        None => {
            report_error(
                "LinAlgError",
                "np_linalg_cholesky",
                file!(),
                line!(),
                column!(),
                "Matrix is not positive definite",
            );
        }
    };
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_qr(
    mat1: *mut InputMatrix,
    out_q: *mut InputMatrix,
    out_r: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let out_q = out_q.as_mut().unwrap();
    let out_r = out_r.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_cholesky", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let outq_dim = (*out_q).get_dims();
    let outr_dim = (*out_r).get_dims();
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let out_q_slice = unsafe { slice::from_raw_parts_mut(out_q.data, outq_dim[0] * outq_dim[1]) };
    let out_r_slice = unsafe { slice::from_raw_parts_mut(out_r.data, outr_dim[0] * outr_dim[1]) };
    // Refer to https://github.com/dimforge/nalgebra/issues/735
    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let res = matrix1.qr();
    let (q, r) = res.unpack();
    // Uses different algo need to match numpy
    out_q_slice.copy_from_slice(q.transpose().as_slice());
    out_r_slice.copy_from_slice(r.transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_svd(
    mat1: *mut InputMatrix,
    outu: *mut InputMatrix,
    outs: *mut InputMatrix,
    outvh: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let outu = outu.as_mut().unwrap();
    let outs = outs.as_mut().unwrap();
    let outvh = outvh.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_svd", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let outu_dim = (*outu).get_dims();
    let outs_dim = (*outs).get_dims();
    let outvh_dim = (*outvh).get_dims();
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let out_u_slice = unsafe { slice::from_raw_parts_mut(outu.data, outu_dim[0] * outu_dim[1]) };
    let out_s_slice = unsafe { slice::from_raw_parts_mut(outs.data, outs_dim[0]) };
    let out_vh_slice =
        unsafe { slice::from_raw_parts_mut(outvh.data, outvh_dim[0] * outvh_dim[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let result = matrix.svd(true, true);
    out_u_slice.copy_from_slice(result.u.unwrap().transpose().as_slice());
    out_s_slice.copy_from_slice(result.singular_values.as_slice());
    out_vh_slice.copy_from_slice(result.v_t.unwrap().transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_inv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
    let mat1 = mat1.as_mut().unwrap();
    let out = out.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    if dim1[0] != dim1[1] {
        let err_msg =
            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
        report_error("LinAlgError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
    }
    let outdim = out.get_dims();
    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    if !matrix.is_invertible() {
        report_error(
            "LinAlgError",
            "np_linalg_inv",
            file!(),
            line!(),
            column!(),
            "no inverse for Singular Matrix",
        );
    }
    let inv = matrix.try_inverse().unwrap();
    out_slice.copy_from_slice(inv.transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_pinv(mat1: *mut InputMatrix, out: *mut InputMatrix) {
    let mat1 = mat1.as_mut().unwrap();
    let out = out.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_pinv", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let outdim = out.get_dims();
    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let svd = matrix.svd(true, true);
    let inv = svd.pseudo_inverse(1e-15);
    match inv {
        Ok(m) => {
            out_slice.copy_from_slice(m.transpose().as_slice());
        }
        Err(err_msg) => {
            report_error("LinAlgError", "np_linalg_pinv", file!(), line!(), column!(), err_msg);
        }
    }
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_matrix_power(
    mat1: *mut InputMatrix,
    mat2: *mut InputMatrix,
    out: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let mat2 = mat2.as_mut().unwrap();
    let out = out.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D", mat1.ndims);
        report_error("ValueError", "np_linalg_matrix_power", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let power = unsafe { slice::from_raw_parts_mut(mat2.data, 1) };
    let power = power[0];
    let outdim = out.get_dims();
    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, outdim[0] * outdim[1]) };
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let abs_pow = power.abs();
    let matrix1 = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let mut result = matrix1.pow(abs_pow as u32);
    if power < 0.0 {
        if !result.is_invertible() {
            report_error(
                "LinAlgError",
                "np_linalg_inv",
                file!(),
                line!(),
                column!(),
                "no inverse for Singular Matrix",
            );
        }
        result = result.try_inverse().unwrap();
    }
    out_slice.copy_from_slice(result.transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn np_linalg_det(mat1: *mut InputMatrix, out: *mut InputMatrix) {
    let mat1 = mat1.as_mut().unwrap();
    let out = out.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "np_linalg_det", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let out_slice = unsafe { slice::from_raw_parts_mut(out.data, 1) };
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    if !matrix.is_square() {
        let err_msg =
            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
        report_error("LinAlgError", "np_linalg_inv", file!(), line!(), column!(), &err_msg);
    }
    out_slice[0] = matrix.determinant();
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn sp_linalg_lu(
    mat1: *mut InputMatrix,
    out_l: *mut InputMatrix,
    out_u: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let out_l = out_l.as_mut().unwrap();
    let out_u = out_u.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "sp_linalg_lu", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    let outl_dim = (*out_l).get_dims();
    let outu_dim = (*out_u).get_dims();
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let out_l_slice = unsafe { slice::from_raw_parts_mut(out_l.data, outl_dim[0] * outl_dim[1]) };
    let out_u_slice = unsafe { slice::from_raw_parts_mut(out_u.data, outu_dim[0] * outu_dim[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let (_, l, u) = matrix.lu().unpack();
    out_l_slice.copy_from_slice(l.transpose().as_slice());
    out_u_slice.copy_from_slice(u.transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn sp_linalg_schur(
    mat1: *mut InputMatrix,
    out_t: *mut InputMatrix,
    out_z: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let out_t = out_t.as_mut().unwrap();
    let out_z = out_z.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "sp_linalg_schur", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    if dim1[0] != dim1[1] {
        let err_msg =
            format!("last 2 dimensions of the array must be square: {0} != {1}", dim1[0], dim1[1]);
        report_error("LinAlgError", "np_linalg_schur", file!(), line!(), column!(), &err_msg);
    }
    let out_t_dim = (*out_t).get_dims();
    let out_z_dim = (*out_z).get_dims();
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let out_t_slice = unsafe { slice::from_raw_parts_mut(out_t.data, out_t_dim[0] * out_t_dim[1]) };
    let out_z_slice = unsafe { slice::from_raw_parts_mut(out_z.data, out_z_dim[0] * out_z_dim[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let (z, t) = matrix.schur().unpack();
    out_t_slice.copy_from_slice(t.transpose().as_slice());
    out_z_slice.copy_from_slice(z.transpose().as_slice());
 }
 /// # Safety
 ///
 /// `mat1` should point to a valid 2DArray of `f64` floats in row-major order
 #[no_mangle]
 pub unsafe extern "C" fn sp_linalg_hessenberg(
    mat1: *mut InputMatrix,
    out_h: *mut InputMatrix,
    out_q: *mut InputMatrix,
 ) {
    let mat1 = mat1.as_mut().unwrap();
    let out_h = out_h.as_mut().unwrap();
    let out_q = out_q.as_mut().unwrap();
    if mat1.ndims != 2 {
        let err_msg = format!("expected 2D Vector Input, but received {}D input", mat1.ndims);
        report_error("ValueError", "sp_linalg_hessenberg", file!(), line!(), column!(), &err_msg);
    }
    let dim1 = (*mat1).get_dims();
    if dim1[0] != dim1[1] {
        let err_msg =
            format!("last 2 dimensions of the array must be square: {} != {}", dim1[0], dim1[1]);
        report_error("LinAlgError", "sp_linalg_hessenberg", file!(), line!(), column!(), &err_msg);
    }
    let out_h_dim = (*out_h).get_dims();
    let out_q_dim = (*out_q).get_dims();
    let data_slice1 = unsafe { slice::from_raw_parts_mut(mat1.data, dim1[0] * dim1[1]) };
    let out_h_slice = unsafe { slice::from_raw_parts_mut(out_h.data, out_h_dim[0] * out_h_dim[1]) };
    let out_q_slice = unsafe { slice::from_raw_parts_mut(out_q.data, out_q_dim[0] * out_q_dim[1]) };
    let matrix = DMatrix::from_row_slice(dim1[0], dim1[1], data_slice1);
    let (q, h) = matrix.hessenberg().unpack();
    out_h_slice.copy_from_slice(h.transpose().as_slice());
    out_q_slice.copy_from_slice(q.transpose().as_slice());
 }
--- a/nac3standalone/demo/run_demo.sh
+++ b/nac3standalone/demo/run_demo.sh
@ -2,6 +2,9 @@
 set -e
 : "${DEMO_LINALG_STUB:=linalg/target/release/liblinalg.a}"
 : "${DEMO_LINALG_STUB32:=linalg/target/i686-unknown-linux-gnu/release/liblinalg.a}"
 if [ -z "$1" ]; then
    echo "No argument supplied"
    exit 1
@ -11,25 +14,26 @@ declare -a nac3args
 while [ $# -ge 1 ]; do
  case "$1" in
    --help)
-      echo "Usage: run_demo.sh [--help] [--out OUTFILE] [--lli] [--debug] -- [NAC3ARGS...]"
+      echo "Usage: run_demo.sh [--help] [--out OUTFILE] [--debug] [-i686] -- [NAC3ARGS...] demo"
      exit
      ;;
    --out)
      shift
      outfile="$1"
      ;;
    --lli)
      use_lli=1
      ;;
    --debug)
      debug=1
      ;;
    -i686)
      i686=1
      ;;
    --)
      shift
      break
      ;;
    *)
-      break
+      echo "Unrecognized argument \"$1\""
      exit 1
      ;;
  esac
  shift
@ -50,29 +54,19 @@ else
 fi
 rm -f ./*.o ./*.bc demo
 if [ -z "$use_lli" ]; then
  $nac3standalone "${nac3args[@]}"
 if [ -z "$i686" ]; then
  $nac3standalone "${nac3args[@]}"
  clang -c -std=gnu11 -Wall -Wextra -O3 -o demo.o demo.c
-  clang -lm -o demo module.o demo.o
+  clang -o demo module.o demo.o $DEMO_LINALG_STUB -lm -Wl,--no-warn-search-mismatch
 else
  $nac3standalone --triple i686-unknown-linux-gnu --target-features +sse2 "${nac3args[@]}"
  clang -m32 -c -std=gnu11 -Wall -Wextra -O3 -msse2 -o demo.o demo.c
  clang -m32 -o demo module.o demo.o $DEMO_LINALG_STUB32 -lm -Wl,--no-warn-search-mismatch
 fi
 if [ -z "$outfile" ]; then
  ./demo
 else
  ./demo > "$outfile"
 fi
 else
  $nac3standalone --emit-llvm "${nac3args[@]}"
  clang -c -std=gnu11 -Wall -Wextra -O3 -emit-llvm -o demo.bc demo.c
  shopt -s nullglob
  llvm-link -o nac3out.bc module*.bc main.bc
  shopt -u nullglob
  if [ -z "$outfile" ]; then
    lli --extra-module demo.bc --extra-module irrt.bc nac3out.bc
  else
    lli --extra-module demo.bc --extra-module irrt.bc nac3out.bc > "$outfile"
  fi
 fi
--- a/nac3standalone/demo/src/assignment.py
+++ b/nac3standalone/demo/src/assignment.py
@ -0,0 +1,76 @@
@extern
 def output_int32(x: int32):
    ...
@extern
 def output_bool(x: bool):
    ...
 def example1():
    x, *ys, z = (1, 2, 3, 4, 5)
    output_int32(x)
    output_int32(len(ys))
    output_int32(ys[0])
    output_int32(ys[1])
    output_int32(ys[2])
    output_int32(z)
 def example2():
    x, y, *zs = (1, 2, 3, 4, 5)
    output_int32(x)
    output_int32(y)
    output_int32(len(zs))
    output_int32(zs[0])
    output_int32(zs[1])
    output_int32(zs[2])
 def example3():
    *xs, y, z = (1, 2, 3, 4, 5)
    output_int32(len(xs))
    output_int32(xs[0])
    output_int32(xs[1])
    output_int32(xs[2])
    output_int32(y)
    output_int32(z)
 def example4():
    *xs, y, z = (4, 5)
    output_int32(len(xs))
    output_int32(y)
    output_int32(z)
 def example5():
    # Example from: https://docs.python.org/3/reference/simple_stmts.html#assignment-statements
    x = [0, 1]
    i = 0
    i, x[i] = 1, 2 # i is updated, then x[i] is updated
    output_int32(i)
    output_int32(x[0])
    output_int32(x[1])
 class A:
    value: int32
    def __init__(self):
        self.value = 1000
 def example6():
    ws = [88, 7, 8]
    a = A()
    x, [y, *ys, a.value], ws[0], (ws[0],) = 1, (2, False, 4, 5), 99, (6,)
    output_int32(x)
    output_int32(y)
    output_bool(ys[0])
    output_int32(ys[1])
    output_int32(a.value)
    output_int32(ws[0])
    output_int32(ws[1])
    output_int32(ws[2])
 def run() -> int32:
    example1()
    example2()
    example3()
    example4()
    example5()
    example6()
    return 0
--- a/nac3standalone/demo/src/classes.py
+++ b/nac3standalone/demo/src/classes.py
@ -7,7 +7,7 @@ def output_int64(x: int64):
    ...
@extern
-def output_str(x: str):
+def output_strln(x: str):
    ...
@ -33,7 +33,7 @@ class A:
 class Initless:
    def foo(self):
-        output_str("hello")
+        output_strln("hello")
 def run() -> int32:
    a = A(10)
--- a/nac3standalone/demo/src/demo_test.py
+++ b/nac3standalone/demo/src/demo_test.py
@ -22,6 +22,10 @@ def output_uint64(x: uint64):
 def output_float64(x: float):
    ...
@extern
 def output_range(x: range):
    ...
@extern
 def output_int32_list(x: list[int32]):
    ...
@ -34,6 +38,10 @@ def output_asciiart(x: int32):
 def output_str(x: str):
    ...
@extern
 def output_strln(x: str):
    ...
 def test_output_bool():
    output_bool(True)
    output_bool(False)
@ -59,6 +67,15 @@ def test_output_float64():
    output_float64(16.25)
    output_float64(-16.25)
 def test_output_range():
    r = range(1, 100, 5)
    output_int32(r.start)
    output_int32(r.stop)
    output_int32(r.step)
    output_range(range(10))
    output_range(range(1, 10))
    output_range(range(1, 10, 2))
 def test_output_asciiart():
    for i in range(17):
        output_asciiart(i)
@ -68,7 +85,8 @@ def test_output_int32_list():
    output_int32_list([0, 1, 3, 5, 10])
 def test_output_str_family():
-    output_str("hello world")
+    output_str("hello")
    output_strln(" world")
 def run() -> int32:
    test_output_bool()
@ -77,6 +95,7 @@ def run() -> int32:
    test_output_uint32()
    test_output_uint64()
    test_output_float64()
    test_output_range()
    test_output_asciiart()
    test_output_int32_list()
    test_output_str_family()
--- a/nac3standalone/demo/src/inheritance.py
+++ b/nac3standalone/demo/src/inheritance.py
@ -10,23 +10,58 @@ class A:
    def __init__(self, a: int32):
        self.a = a
-    def f1(self):
+    def output_all_fields(self):
        self.f2()
    def f2(self):
        output_int32(self.a)
    def set_a(self, a: int32):
        self.a = a
 class B(A):
    b: int32
    def __init__(self, b: int32):
-        self.a = b + 1
+        A.__init__(self, b + 1)
        self.set_b(b)
    def output_parent_fields(self):
        A.output_all_fields(self)
    def output_all_fields(self):
        A.output_all_fields(self)
        output_int32(self.b)
    def set_b(self, b: int32):
        self.b = b
 class C(B):
    c: int32
    def __init__(self, c: int32):
        B.__init__(self, c + 1)
        self.c = c
    def output_parent_fields(self):
        B.output_all_fields(self)
    def output_all_fields(self):
        B.output_all_fields(self)
        output_int32(self.c)
    def set_c(self, c: int32):
        self.c = c
 def run() -> int32:
-    aaa = A(5)
+    ccc = C(10)
-    bbb = B(2)
+    ccc.output_all_fields()
-    aaa.f1()
+    ccc.set_a(1)
-    bbb.f1()
+    ccc.set_b(2)
    ccc.set_c(3)
    ccc.output_all_fields()
    bbb = B(10)
    bbb.set_a(9)
    bbb.set_b(8)
    bbb.output_all_fields()
    ccc.output_all_fields()
    return 0
--- a/nac3standalone/demo/src/lists.py
+++ b/nac3standalone/demo/src/lists.py
@ -1,3 +1,7 @@
@extern
 def output_bool(x: bool):
    ...
@extern
 def output_int32_list(x: list[int32]):
    ...
@ -30,6 +34,32 @@ def run() -> int32:
    get_list_slice()
    list_slice_assignment()
    output_int32_list([1, 2, 3] + [4, 5, 6])
    output_int32_list([1, 2, 3] * 3)
    output_bool([] == [])
    output_bool([0] == [])
    output_bool([0] == [0])
    output_bool([0, 1] == [0])
    output_bool([0, 1] == [0, 1])
    output_bool([] != [])
    output_bool([0] != [])
    output_bool([0] != [0])
    output_bool([0] != [0, 1])
    output_bool([0, 1] != [0, 1])
    output_bool([] == [] == [])
    output_bool([0] == [0] == [0])
    output_bool([0, 1] == [0] == [0, 1])
    output_bool([0, 1] == [0, 1] == [0])
    output_bool([0] == [0, 1] == [0, 1])
    output_bool([0, 1] == [0, 1] == [0, 1])
    output_bool([] != [] != [])
    output_bool([0] != [0] != [0])
    output_bool([0, 1] != [0] != [0, 1])
    output_bool([0, 1] != [0, 1] != [0])
    output_bool([0] != [0, 1] != [0, 1])
    output_bool([0, 1] != [0, 1] != [0, 1])
    return 0
 def get_list_slice():
--- a/nac3standalone/demo/src/loop_try_break.py
+++ b/nac3standalone/demo/src/loop_try_break.py
@ -23,11 +23,12 @@ def run() -> int32:
                    output_int32(x)
                    output_str(" * ")
                    output_float64(n / x)
                    output_str("\n")
            except:  # Assume this is intended to catch x == 0
                break
        else:
            # loop fell through without finding a factor
            output_int32(n)
-            output_str(" is a prime number")
+            output_str(" is a prime number\n")
    return 0
--- a/nac3standalone/demo/src/math.py
+++ b/nac3standalone/demo/src/math.py
@ -37,7 +37,7 @@ def test_round64():
        output_int64(round64(x))
 def test_np_round():
-    for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan()]:
+    for x in [-1.5, -0.5, 0.5, 1.5, dbl_inf(), -dbl_inf(), dbl_nan(), 0.0, -0.0, 1.6, 1.4, -1.4, -1.6]:
        output_float64(np_round(x))
 def test_np_isnan():
--- a/nac3standalone/demo/src/ndarray.py
+++ b/nac3standalone/demo/src/ndarray.py
@ -71,28 +71,65 @@ def output_ndarray_float_2(n: ndarray[float, Literal[2]]):
 def consume_ndarray_1(n: ndarray[float, Literal[1]]):
    pass
 def consume_ndarray_2(n: ndarray[float, Literal[2]]):
    pass
 def test_ndarray_ctor():
    n: ndarray[float, Literal[1]] = np_ndarray([1])
    consume_ndarray_1(n)
 def test_ndarray_empty():
-    n: ndarray[float, 1] = np_empty([1])
+    n1: ndarray[float, 1] = np_empty([1])
-    consume_ndarray_1(n)
+    consume_ndarray_1(n1)
    n2: ndarray[float, 1] = np_empty(10)
    consume_ndarray_1(n2)
    n3: ndarray[float, 1] = np_empty((2,))
    consume_ndarray_1(n3)
    n4: ndarray[float, 2] = np_empty((4, 4))
    consume_ndarray_2(n4)
    dim4 = (5, 2)
    n5: ndarray[float, 2] = np_empty(dim4)
    consume_ndarray_2(n5)
 def test_ndarray_zeros():
-    n: ndarray[float, 1] = np_zeros([1])
+    n1: ndarray[float, 1] = np_zeros([1])
-    output_ndarray_float_1(n)
+    output_ndarray_float_1(n1)
    k = 3 + int32(n1[0]) # to test variable shape inputs
    n2: ndarray[float, 1] = np_zeros(k * k)
    output_ndarray_float_1(n2)
    n3: ndarray[float, 1] = np_zeros((k * 2,))
    output_ndarray_float_1(n3)
    dim4 = (3, 2 * k)
    n4: ndarray[float, 2] = np_zeros(dim4)
    output_ndarray_float_2(n4)
 def test_ndarray_ones():
    n: ndarray[float, 1] = np_ones([1])
    output_ndarray_float_1(n)
    dim = (1,)
    n_tup: ndarray[float, 1] = np_ones(dim)
    output_ndarray_float_1(n_tup)
 def test_ndarray_full():
    n_float: ndarray[float, 1] = np_full([1], 2.0)
    output_ndarray_float_1(n_float)
    n_i32: ndarray[int32, 1] = np_full([1], 2)
    output_ndarray_int32_1(n_i32)
    dim = (1,)
    n_float_tup: ndarray[float, 1] = np_full(dim, 2.0)
    output_ndarray_float_1(n_float_tup)
    n_i32_tup: ndarray[int32, 1] = np_full(dim, 2)
    output_ndarray_int32_1(n_i32_tup)
 def test_ndarray_eye():
    n: ndarray[float, 2] = np_eye(2)
    output_ndarray_float_2(n)
@ -840,6 +877,13 @@ def test_ndarray_minimum_broadcast_rhs_scalar():
    output_ndarray_float_2(min_x_zeros)
    output_ndarray_float_2(min_x_ones)
 def test_ndarray_argmin():
    x = np_array([[1., 2.], [3., 4.]])
    y = np_argmin(x)
    output_ndarray_float_2(x)
    output_int64(y)
 def test_ndarray_max():
    x = np_identity(2)
    y = np_max(x)
@ -883,6 +927,13 @@ def test_ndarray_maximum_broadcast_rhs_scalar():
    output_ndarray_float_2(max_x_zeros)
    output_ndarray_float_2(max_x_ones)
 def test_ndarray_argmax():
    x = np_array([[1., 2.], [3., 4.]])
    y = np_argmax(x)
    output_ndarray_float_2(x)
    output_int64(y)
 def test_ndarray_abs():
    x = np_identity(2)
    y = abs(x)
@ -1388,47 +1439,141 @@ def test_ndarray_nextafter_broadcast_rhs_scalar():
    output_ndarray_float_2(nextafter_x_zeros)
    output_ndarray_float_2(nextafter_x_ones)
-def test_ndarray_any():
+def test_ndarray_transpose():
-    x1 = np_identity(5)
+    x: ndarray[float, 2] = np_array([[1., 2., 3.], [4., 5., 6.]])
-    y1 = np_any(x1)
+    y = np_transpose(x)
-    output_ndarray_float_2(x1)
+    z = np_transpose(y)
    output_bool(y1)
-    x2 = np_identity(1)
+    output_ndarray_float_2(x)
-    y2 = np_any(x2)
+    output_ndarray_float_2(y)
    output_ndarray_float_2(x2)
    output_bool(y2)
-    x3 = np_array([[1.0, 2.0], [3.0, 4.0]])
+def test_ndarray_reshape():
-    y3 = np_any(x3)
+    w: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
-    output_ndarray_float_2(x3)
+    x = np_reshape(w, (1, 2, 1, -1))
-    output_bool(y3)
+    y = np_reshape(x, [2, -1])
    z = np_reshape(y, 10)
-    x4 = np_zeros([3, 5])
+    x1: ndarray[int32, 1] = np_array([1, 2, 3, 4])
-    y4 = np_any(x4)
+    x2: ndarray[int32, 2] = np_reshape(x1, (2, 2))
    output_ndarray_float_2(x4)
    output_bool(y4)
-def test_ndarray_all():
+    output_ndarray_float_1(w)
-    x1 = np_identity(5)
+    output_ndarray_float_2(y)
-    y1 = np_all(x1)
+    output_ndarray_float_1(z)
    output_ndarray_float_2(x1)
    output_bool(y1)
-    x2 = np_identity(1)
+def test_ndarray_dot():
-    y2 = np_all(x2)
+    x1: ndarray[float, 1] = np_array([5.0, 1.0, 4.0, 2.0])
-    output_ndarray_float_2(x2)
+    y1: ndarray[float, 1] = np_array([5.0, 1.0, 6.0, 6.0])
-    output_bool(y2)
+    z1 = np_dot(x1, y1)
-    x3 = np_array([[1.0, 2.0], [3.0, 4.0]])
+    x2: ndarray[int32, 1] = np_array([5, 1, 4, 2])
-    y3 = np_all(x3)
+    y2: ndarray[int32, 1] = np_array([5, 1, 6, 6])
-    output_ndarray_float_2(x3)
+    z2 = np_dot(x2, y2)
-    output_bool(y3)
+
    x3: ndarray[bool, 1] = np_array([True, True, True, True])
    y3: ndarray[bool, 1] = np_array([True, True, True, True])
    z3 = np_dot(x3, y3)
    z4 = np_dot(2, 3)
    z5 = np_dot(2., 3.)
    z6 = np_dot(True, False)
    output_float64(z1)
    output_int32(z2)
    output_bool(z3)
    output_int32(z4)
    output_float64(z5)
    output_bool(z6)
 def test_ndarray_cholesky():
    x: ndarray[float, 2] = np_array([[5.0, 1.0], [1.0, 4.0]])
    y = np_linalg_cholesky(x)
    output_ndarray_float_2(x)
    output_ndarray_float_2(y)
 def test_ndarray_qr():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    y, z  = np_linalg_qr(x)
    output_ndarray_float_2(x)
    # QR Factorization is not unique and gives different results in numpy and nalgebra
    # Reverting the decomposition to compare the initial arrays
    a = y @ z
    output_ndarray_float_2(a)
 def test_ndarray_linalg_inv():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    y = np_linalg_inv(x)
    output_ndarray_float_2(x)
    output_ndarray_float_2(y)
 def test_ndarray_pinv():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5]])
    y = np_linalg_pinv(x)
    output_ndarray_float_2(x)
    output_ndarray_float_2(y)
 def test_ndarray_matrix_power():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    y = np_linalg_matrix_power(x, -9)
    output_ndarray_float_2(x)
    output_ndarray_float_2(y)
 def test_ndarray_det():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    y = np_linalg_det(x)
    output_ndarray_float_2(x)
    output_float64(y)
 def test_ndarray_schur():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    t, z = sp_linalg_schur(x)
    output_ndarray_float_2(x)
    # Schur Factorization is not unique and gives different results in scipy and nalgebra
    # Reverting the decomposition to compare the initial arrays
    a = (z @ t) @ np_linalg_inv(z)
    output_ndarray_float_2(a)
 def test_ndarray_hessenberg():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 5.0, 8.5]])
    h, q = sp_linalg_hessenberg(x)
    output_ndarray_float_2(x)
    # Hessenberg Factorization is not unique and gives different results in scipy and nalgebra
    # Reverting the decomposition to compare the initial arrays
    a = (q @ h) @ np_linalg_inv(q)
    output_ndarray_float_2(a)
 def test_ndarray_lu():
    x: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5]])
    l, u = sp_linalg_lu(x)
    output_ndarray_float_2(x)
    output_ndarray_float_2(l)
    output_ndarray_float_2(u)
 def test_ndarray_svd():
    w: ndarray[float, 2] = np_array([[-5.0, -1.0, 2.0], [-1.0, 4.0, 7.5], [-1.0, 8.0, -8.5]])
    x, y, z = np_linalg_svd(w)
    output_ndarray_float_2(w)
    # SVD Factorization is not unique and gives different results in numpy and nalgebra
    # Reverting the decomposition to compare the initial arrays
    a = x @ z
    output_ndarray_float_2(a)
    output_ndarray_float_1(y)
    x4 = np_zeros([3, 5])
    y4 = np_all(x4)
    output_ndarray_float_2(x4)
    output_bool(y4)
 def run() -> int32:
    test_ndarray_ctor()
@ -1534,16 +1679,19 @@ def run() -> int32:
    test_ndarray_round()
    test_ndarray_floor()
    test_ndarray_ceil()
    test_ndarray_min()
    test_ndarray_minimum()
    test_ndarray_minimum_broadcast()
    test_ndarray_minimum_broadcast_lhs_scalar()
    test_ndarray_minimum_broadcast_rhs_scalar()
    test_ndarray_argmin()
    test_ndarray_max()
    test_ndarray_maximum()
    test_ndarray_maximum_broadcast()
    test_ndarray_maximum_broadcast_lhs_scalar()
    test_ndarray_maximum_broadcast_rhs_scalar()
    test_ndarray_argmax()
    test_ndarray_abs()
    test_ndarray_isnan()
    test_ndarray_isinf()
@ -1606,8 +1754,18 @@ def run() -> int32:
    test_ndarray_nextafter_broadcast()
    test_ndarray_nextafter_broadcast_lhs_scalar()
    test_ndarray_nextafter_broadcast_rhs_scalar()
    test_ndarray_transpose()
    test_ndarray_reshape()
-    test_ndarray_any()
+    test_ndarray_dot()
-    test_ndarray_all()
+    test_ndarray_cholesky()
-
+    test_ndarray_qr()
    test_ndarray_svd()
    test_ndarray_linalg_inv()
    test_ndarray_pinv()
    test_ndarray_matrix_power()
    test_ndarray_det()
    test_ndarray_lu()
    test_ndarray_schur()
    test_ndarray_hessenberg()
    return 0
--- a/nac3standalone/demo/src/str.py
+++ b/nac3standalone/demo/src/str.py
@ -0,0 +1,30 @@
@extern
 def output_bool(x: bool):
    ...
 def str_eq():
    output_bool("" == "")
    output_bool("a" == "")
    output_bool("a" == "b")
    output_bool("b" == "a")
    output_bool("a" == "a")
    output_bool("test string" == "test string")
    output_bool("test string1" == "test string2")
 def str_ne():
    output_bool("" != "")
    output_bool("a" != "")
    output_bool("a" != "b")
    output_bool("b" != "a")
    output_bool("a" != "a")
    output_bool("test string" != "test string")
    output_bool("test string1" != "test string2")
 def run() -> int32:
    str_eq()
    str_ne()
    return 0
--- a/nac3standalone/demo/src/tuple.py
+++ b/nac3standalone/demo/src/tuple.py
@ -1,3 +1,7 @@
@extern
 def output_bool(b: bool):
    ...
@extern
 def output_int32_list(x: list[int32]):
    ...
@ -13,6 +17,41 @@ class A:
        self.a = a
        self.b = b
 def test_tuple_eq():
    # 0-len
    output_bool(() == ())
    # 1-len
    output_bool((1,) == ())
    output_bool(() == (1,))
    output_bool((1,) == (1,))
    output_bool((1,) == (2,))
    # # 2-len
    output_bool((1, 2) == ())
    output_bool(() == (1, 2))
    output_bool((1,) == (1, 2))
    output_bool((1, 2) == (1,))
    output_bool((2, 2) == (1, 2))
    output_bool((1, 2) == (2, 2))
 def test_tuple_ne():
    # 0-len
    output_bool(() != ())
    # 1-len
    output_bool((1,) != ())
    output_bool(() != (1,))
    output_bool((1,) != (1,))
    output_bool((1,) != (2,))
    # 2-len
    output_bool((1, 2) != ())
    output_bool(() != (1, 2))
    output_bool((1,) != (1, 2))
    output_bool((1, 2) != (1,))
    output_bool((2, 2) != (1, 2))
    output_bool((1, 2) != (2, 2))
 def run() -> int32:
    data = [0, 1, 2, 3]
@ -26,4 +65,14 @@ def run() -> int32:
        output_int32(tl[0][1])
        output_int32(tl[1])
    output_int32(len(()))
    output_int32(len((1,)))
    output_int32(len((1, 2)))
    output_int32(len((1, 2, 3)))
    output_int32(len((1, 2, 3, 4)))
    output_int32(len((1, 2, 3, 4, 5)))
    test_tuple_eq()
    test_tuple_ne()
    return 0
--- a/nac3standalone/demo/src/vararg.py
+++ b/nac3standalone/demo/src/vararg.py
@ -0,0 +1,11 @@
 def f(*args: int32):
    pass
 def run() -> int32:
    f()
    f(1)
    f(1, 2)
    f(1, 2, 3)
    return 0
--- a/nac3standalone/src/basic_symbol_resolver.rs
+++ b/nac3standalone/src/basic_symbol_resolver.rs
@ -1,3 +1,4 @@
 use nac3core::nac3parser::ast::{self, StrRef};
 use nac3core::{
    codegen::CodeGenContext,
    symbol_resolver::{SymbolResolver, SymbolValue, ValueEnum},
@ -7,7 +8,6 @@ use nac3core::{
        typedef::{Type, Unifier},
    },
 };
 use nac3parser::ast::{self, StrRef};
 use parking_lot::{Mutex, RwLock};
 use std::collections::HashSet;
 use std::{collections::HashMap, sync::Arc};
@ -15,7 +15,6 @@ use std::{collections::HashMap, sync::Arc};
 pub struct ResolverInternal {
    pub id_to_type: Mutex<HashMap<StrRef, Type>>,
    pub id_to_def: Mutex<HashMap<StrRef, DefinitionId>>,
    pub class_names: Mutex<HashMap<StrRef, Type>>,
    pub module_globals: Mutex<HashMap<StrRef, SymbolValue>>,
    pub str_store: Mutex<HashMap<String, i32>>,
 }
--- a/nac3standalone/src/main.rs
+++ b/nac3standalone/src/main.rs
@ -9,15 +9,14 @@
 #![allow(clippy::too_many_lines, clippy::wildcard_imports)]
 use clap::Parser;
-use inkwell::{
+use nac3core::inkwell::{
-    memory_buffer::MemoryBuffer, passes::PassBuilderOptions, support::is_multithreaded, targets::*,
+    memory_buffer::MemoryBuffer, module::Linkage, passes::PassBuilderOptions,
-    OptimizationLevel,
+    support::is_multithreaded, targets::*, OptimizationLevel,
 };
 use nac3core::nac3parser::{
    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
    parser,
 };
 use parking_lot::{Mutex, RwLock};
 use std::collections::HashSet;
 use std::num::NonZeroUsize;
 use std::{collections::HashMap, fs, path::Path, sync::Arc};
 use nac3core::{
    codegen::{
        concrete_type::ConcreteTypeStore, irrt::load_irrt, CodeGenLLVMOptions,
@ -35,10 +34,10 @@ use nac3core::{
        typedef::{FunSignature, Type, Unifier, VarMap},
    },
 };
-use nac3parser::{
+use parking_lot::{Mutex, RwLock};
-    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
+use std::collections::HashSet;
-    parser,
+use std::num::NonZeroUsize;
-};
+use std::{collections::HashMap, fs, path::Path, sync::Arc};
 mod basic_symbol_resolver;
 use basic_symbol_resolver::*;
@ -113,7 +112,9 @@ fn handle_typevar_definition(
                        x,
                        HashMap::new(),
                    )?;
-                    get_type_from_type_annotation_kinds(def_list, unifier, &ty, &mut None)
+                    get_type_from_type_annotation_kinds(
                        def_list, unifier, primitives, &ty, &mut None,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?;
            let loc = func.location;
@ -152,7 +153,7 @@ fn handle_typevar_definition(
                HashMap::new(),
            )?;
            let constraint =
-                get_type_from_type_annotation_kinds(def_list, unifier, &ty, &mut None)?;
+                get_type_from_type_annotation_kinds(def_list, unifier, primitives, &ty, &mut None)?;
            let loc = func.location;
            Ok(unifier.get_fresh_const_generic_var(constraint, Some(generic_name), Some(loc)).ty)
@ -239,8 +240,6 @@ fn handle_assignment_pattern(
 }
 fn main() {
    const SIZE_T: u32 = usize::BITS;
    let cli = CommandLineArgs::parse();
    let CommandLineArgs { file_name, threads, opt_level, emit_llvm, triple, mcpu, target_features } =
        cli;
@ -273,6 +272,22 @@ fn main() {
        _ => OptimizationLevel::Aggressive,
    };
    let target_machine_options = CodeGenTargetMachineOptions {
        triple,
        cpu: mcpu,
        features: target_features,
        reloc_mode: RelocMode::PIC,
        ..host_target_machine
    };
    let target_machine = target_machine_options
        .create_target_machine(opt_level)
        .expect("couldn't create target machine");
    let context = nac3core::inkwell::context::Context::create();
    let size_t =
        context.ptr_sized_int_type(&target_machine.get_target_data(), None).get_bit_width();
    let program = match fs::read_to_string(file_name.clone()) {
        Ok(program) => program,
        Err(err) => {
@ -281,14 +296,13 @@ fn main() {
        }
    };
-    let primitive: PrimitiveStore = TopLevelComposer::make_primitives(SIZE_T).0;
+    let primitive: PrimitiveStore = TopLevelComposer::make_primitives(size_t).0;
    let (mut composer, builtins_def, builtins_ty) =
-        TopLevelComposer::new(vec![], ComposerConfig::default(), SIZE_T);
+        TopLevelComposer::new(vec![], vec![], ComposerConfig::default(), size_t);
    let internal_resolver: Arc<ResolverInternal> = ResolverInternal {
        id_to_type: builtins_ty.into(),
        id_to_def: builtins_def.into(),
        class_names: Mutex::default(),
        module_globals: Mutex::default(),
        str_store: Mutex::default(),
    }
@ -296,6 +310,13 @@ fn main() {
    let resolver =
        Arc::new(Resolver(internal_resolver.clone())) as Arc<dyn SymbolResolver + Send + Sync>;
    // Process IRRT
    let irrt = load_irrt(&context, resolver.as_ref());
    if emit_llvm {
        irrt.write_bitcode_to_path(Path::new("irrt.bc"));
    }
    // Process the Python script
    let parser_result = parser::parse_program(&program, file_name.into()).unwrap();
    for stmt in parser_result {
@ -340,7 +361,19 @@ fn main() {
    let signature = store.from_signature(&mut composer.unifier, &primitive, &signature, &mut cache);
    let signature = store.add_cty(signature);
-    composer.start_analysis(true).unwrap();
+    if let Err(errors) = composer.start_analysis(true) {
        let error_count = errors.len();
        eprintln!("{error_count} error(s) occurred during top level analysis.");
        for (error_i, error) in errors.iter().enumerate() {
            let error_num = error_i + 1;
            eprintln!("=========== ERROR {error_num}/{error_count} ============");
            eprintln!("{error}");
        }
        eprintln!("==================================");
        panic!("top level analysis failed");
    }
    let top_level = Arc::new(composer.make_top_level_context());
@ -359,16 +392,7 @@ fn main() {
        instance_to_stmt[""].clone()
    };
-    let llvm_options = CodeGenLLVMOptions {
+    let llvm_options = CodeGenLLVMOptions { opt_level, target: target_machine_options };
        opt_level,
        target: CodeGenTargetMachineOptions {
            triple,
            cpu: mcpu,
            features: target_features,
            reloc_mode: RelocMode::PIC,
            ..host_target_machine
        },
    };
    let task = CodeGenTask {
        subst: Vec::default(),
@ -391,14 +415,14 @@ fn main() {
        membuffer.lock().push(buffer);
    })));
    let threads = (0..threads)
-        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), SIZE_T)))
+        .map(|i| Box::new(DefaultCodeGenerator::new(format!("module{i}"), size_t)))
        .collect();
    let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
    registry.add_task(task);
    registry.wait_tasks_complete(handles);
    // Link all modules together into `main`
    let buffers = membuffers.lock();
    let context = inkwell::context::Context::create();
    let main = context
        .create_module_from_ir(MemoryBuffer::create_from_memory_range(&buffers[0], "main"))
        .unwrap();
@ -418,25 +442,18 @@ fn main() {
        main.link_in_module(other).unwrap();
    }
    let irrt = load_irrt(&context);
    if emit_llvm {
        irrt.write_bitcode_to_path(Path::new("irrt.bc"));
    }
    main.link_in_module(irrt).unwrap();
    // Private all functions except "run"
    let mut function_iter = main.get_first_function();
    while let Some(func) = function_iter {
        if func.count_basic_blocks() > 0 && func.get_name().to_str().unwrap() != "run" {
-            func.set_linkage(inkwell::module::Linkage::Private);
+            func.set_linkage(Linkage::Private);
        }
        function_iter = func.get_next_function();
    }
-    let target_machine = llvm_options
+    // Optimize `main`
        .target
        .create_target_machine(llvm_options.opt_level)
        .expect("couldn't create target machine");
    let pass_options = PassBuilderOptions::create();
    pass_options.set_merge_functions(true);
    let passes = format!("default<O{}>", opt_level as u32);
@ -445,6 +462,7 @@ fn main() {
        panic!("Failed to run optimization for module `main`: {}", err.to_string());
    }
    // Write output
    target_machine
        .write_to_file(&main, FileType::Object, Path::new("module.o"))
        .expect("couldn't write module to file");
--- a/nix/windows/PKGBUILD
+++ b/nix/windows/PKGBUILD
@ -21,6 +21,6 @@ build() {
 }
 package() {
-  mkdir -p $pkgdir/clang64/lib/python3.11/site-packages
+  mkdir -p $pkgdir/clang64/lib/python3.12/site-packages
-  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.11/site-packages
+  cp ${srcdir}/nac3artiq.pyd $pkgdir/clang64/lib/python3.12/site-packages
 }
--- a/nix/windows/default.nix
+++ b/nix/windows/default.nix
@ -21,10 +21,10 @@ let
    text =
      ''
      implementation=CPython
-      version=3.11
+      version=3.12
      shared=true
      abi3=false
-      lib_name=python3.11
+      lib_name=python3.12
      lib_dir=${msys2-env}/clang64/lib
      pointer_width=64
      build_flags=WITH_THREAD
--- a/nix/windows/make_msys2_packages.sh
+++ b/nix/windows/make_msys2_packages.sh
@ -6,11 +6,11 @@ cd $(dirname $0)
 MSYS2DIR=`pwd`/msys2
 mkdir -p $MSYS2DIR/var/lib/pacman $MSYS2DIR/msys/etc
-curl -L https://mirror.msys2.org/msys/x86_64/pacman-mirrors-20220205-1-any.pkg.tar.zst | tar xvf - -C $MSYS2DIR --zstd
+curl -L https://repo.msys2.org/msys/x86_64/pacman-mirrors-20240523-1-any.pkg.tar.zst | tar xvf - -C $MSYS2DIR --zstd
 curl -L https://raw.githubusercontent.com/msys2/MSYS2-packages/master/pacman/pacman.conf | sed "s|SigLevel    = Required|SigLevel    = Never|g" | sed "s|/etc/pacman.d|$MSYS2DIR/etc/pacman.d|g" > $MSYS2DIR/etc/pacman.conf
 fakeroot pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf -Syy
-pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf --cachedir $MSYS2DIR/msys/cache -Sp mingw-w64-clang-x86_64-rust mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-ninja mingw-w64-clang-x86_64-python3.11 mingw-w64-clang-x86_64-python-numpy mingw-w64-clang-x86_64-python-setuptools > $MSYS2DIR/packages.txt
+pacman --root $MSYS2DIR --config $MSYS2DIR/etc/pacman.conf --cachedir $MSYS2DIR/msys/cache -Sp mingw-w64-clang-x86_64-rust mingw-w64-clang-x86_64-cmake mingw-w64-clang-x86_64-ninja mingw-w64-clang-x86_64-python-numpy mingw-w64-clang-x86_64-python-setuptools > $MSYS2DIR/packages.txt
 echo "{ pkgs } : [" > msys2_packages.nix
 while read package; do
--- a/nix/windows/msys2_packages.nix
+++ b/nix/windows/msys2_packages.nix
@ -1,15 +1,15 @@
 { pkgs } : [
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunwind-18.1.8-2-any.pkg.tar.zst";
-  sha256 = "0ksz7xz1lbwsmdr9sa1444k0dlfkbd8k11pq7w08ir7r1wjy6fid";
+  sha256 = "0f9m76dx40iy794nfks0360gvjhdg6yngb2lyhwp4xd76rn5081m";
-  name = "mingw-w64-clang-x86_64-libunwind-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libunwind-18.1.8-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libc++-18.1.8-2-any.pkg.tar.zst";
-  sha256 = "0r8skyjqv4cpkqif0niakx4hdpkscil1zf6mzj34pqna0j5gdnq2";
+  sha256 = "17savj9wys9my2ji7vyba7wwqkvzdjwnkb3k4858wxrjbzbfa6lk";
-  name = "mingw-w64-clang-x86_64-libc++-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libc++-18.1.8-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -31,9 +31,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-xz-5.6.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-xz-5.6.2-2-any.pkg.tar.zst";
-  sha256 = "14p4xxaxjjy6j1ingji82xhai1mc1gls5ali6z40fbb2ylxkaggs";
+  sha256 = "0phb9hwqksk1rg29yhwlc7si78zav19c2kac0i841pc7mc2n9gzx";
-  name = "mingw-w64-clang-x86_64-xz-5.6.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-xz-5.6.2-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -43,93 +43,93 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.6-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.9-1-any.pkg.tar.zst";
-  sha256 = "177b3rmsknqq6hf0zqwva71s3avh20ca7vzznp2ls2z5qm8vhhlp";
+  sha256 = "0cjz2vj9yz6k5xj601cp0yk631rrr0z94ciamwqrvclb0yhakf25";
-  name = "mingw-w64-clang-x86_64-libxml2-2.12.6-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libxml2-2.12.9-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-zstd-1.5.5-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-zstd-1.5.6-2-any.pkg.tar.zst";
-  sha256 = "07739wmwgxf0d6db4p8w302a6jwcm01aafr1s8jvcl5k1h5a1m2m";
+  sha256 = "02cp5ci8w50k7xn38mpkwnr8sn898v18wcc07y8f9sfla7vcyfix";
-  name = "mingw-w64-clang-x86_64-zstd-1.5.5-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-zstd-1.5.6-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-libs-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-libs-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "0ibiy01v16naik9pj32ch7a9pkbw4yrn3gyq7p0y6kcc63fkjazy";
+  sha256 = "0rpbgvvinsqflhd3nhfxk0g0yy8j80zzw5yx6573ak0m78a9fa06";
-  name = "mingw-w64-clang-x86_64-llvm-libs-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-llvm-libs-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "1hcfz6nb6svmmcqzfrdi96az2x7mzj0cispdv2ssbgn7nkf19pi0";
+  sha256 = "185g5h8q3x3rav9lp2njln58ny2idh2067fd02j3nsbik6glshpf";
-  name = "mingw-w64-clang-x86_64-llvm-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-llvm-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-libs-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-libs-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "1k17d18g7rmq2ph4kq1mf84vs8133jzf52nkv6syh39ypjga67wa";
+  sha256 = "089hji3yd7wsd03v9mdfgc99l5k1dql8kg7p3hy13vrbgfsabxhc";
-  name = "mingw-w64-clang-x86_64-clang-libs-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-clang-libs-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-compiler-rt-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-compiler-rt-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "1w2j0vs888haz9shjr1l8dc4j957sk1p0377zzipkbqnzqwjf1z8";
+  sha256 = "1dwcxnv1k5ljim5ys4h1c3jlrdpi0054z094ynav7if65i8zjj4a";
-  name = "mingw-w64-clang-x86_64-compiler-rt-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-compiler-rt-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
-  sha256 = "18csfwlk2h9pr4411crx1b41qjzn5jgbssm3h109nzwbdizkp62h";
+  sha256 = "0163jzjlvq7inpafy3h48pkwag3ysk6x56xm84yfcz5q52fnfzq5";
-  name = "mingw-w64-clang-x86_64-headers-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-headers-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-crt-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
-  sha256 = "03l1zkrxgxxssp430xcv2gch1d03rbnbk1c0vgiqxigcs8lljh2g";
+  sha256 = "00cn1mi29mfys7qy4hvgnjd0smqvnkdn3ibnrr6a3wy1h2vaykgq";
-  name = "mingw-w64-clang-x86_64-crt-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-crt-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lld-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lld-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "1ai4gl7ybpk9n10jmbpf3zzfa893m1krj5qhf44ajln0jabdfnbn";
+  sha256 = "1vpij5d06m4kjy3qv8bizwlkl21gcv6fv0r2f1j9bclgm6k3144x";
-  name = "mingw-w64-clang-x86_64-lld-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-lld-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
-  sha256 = "1svhjzwhvl4ldl439jhgfy47g05y2af1cjqvydgijn1dd4g8y8vq";
+  sha256 = "1zkzqqd31xpkv817wja3qssjjx891bsdxw07037hv2sk0qr4ffn9";
-  name = "mingw-w64-clang-x86_64-libwinpthread-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
-  sha256 = "0jxdhkl256vnr13xf1x3fyjrdf764zg70xcs3gki3rg109f0a6xk";
+  sha256 = "02ynia88ad3l03r08nyldmnajwqkyxcjd191lyamkbj4d6zck323";
-  name = "mingw-w64-clang-x86_64-winpthreads-git-11.0.0.r655.gdbfdf8025-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r250.gc6bf4bdf6-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-clang-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "0ahfic7vdfv96k5v7fdkgk1agk28l833xjn2igrmbvqg96ak0w6n";
+  sha256 = "1qny934nv4g75k9gb5sf31v24bgafkg6qw7r35xv3in491w6annq";
-  name = "mingw-w64-clang-x86_64-clang-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-clang-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.27.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.33.1-1-any.pkg.tar.zst";
-  sha256 = "06y3sgqv6a0gr3dsbzs36jrj8adklssgjqi2ms5clsyq6ay4f91r";
+  sha256 = "14r6jjsvfbapbkv2zqp2yglva4vz4srzkgk7f186ri3kcafjspgq";
-  name = "mingw-w64-clang-x86_64-c-ares-1.27.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-c-ares-1.33.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-brotli-1.1.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-brotli-1.1.0-2-any.pkg.tar.zst";
-  sha256 = "113mha41q53cx0hw13cq1xdf7zbsd58sh8cl1cd7xzg1q69n60w2";
+  sha256 = "1q01lz9lcyrjmkhv9rddgjazmk7warlcmwhc4qkq9y6h0yfsb71n";
-  name = "mingw-w64-clang-x86_64-brotli-1.1.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-brotli-1.1.0-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunistring-1.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libunistring-1.2-1-any.pkg.tar.zst";
-  sha256 = "16myvbg33q5s7jl30w5qd8n8f1r05335ms8r61234vn52n32l2c4";
+  sha256 = "13nz49li39z1zgfx1q9jg4vrmyrmqb6qdq0nqshidaqc6zr16k3g";
-  name = "mingw-w64-clang-x86_64-libunistring-1.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libunistring-1.2-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -151,9 +151,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-p11-kit-0.25.3-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-p11-kit-0.25.5-1-any.pkg.tar.zst";
-  sha256 = "1jrwkc4lvw5hm5rqmi5gqh7mfkbqfa5gi81zjij0krnl0gaxw3c8";
+  sha256 = "00yz6cmr1ldlrskv811n345xcia88mj7w4fyx4m9z5848jxgsabd";
-  name = "mingw-w64-clang-x86_64-p11-kit-0.25.3-2-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-p11-kit-0.25.5-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -163,9 +163,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.2.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.3.2-1-any.pkg.tar.zst";
-  sha256 = "0ix2r4ll09m2z5vz2k94gmwfs0pp3ipvjdimwzx7v6xhcs2l25lz";
+  sha256 = "1djgpcz447yvhdy1yq5wh8l5d0821izxklx9afyszbw0pbr7f24y";
-  name = "mingw-w64-clang-x86_64-openssl-3.2.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-openssl-3.3.2-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -175,33 +175,39 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.60.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.63.0-1-any.pkg.tar.zst";
-  sha256 = "0wxw8266hf4qd2m4zpgb1wvlrnaksmcrs0kh5y9zpf2y5sy8f2bq";
+  sha256 = "0lfqrlmapsc7ilxjmhr7hxi578vclqlhpqimbvzq0c70c0iwk864";
-  name = "mingw-w64-clang-x86_64-nghttp2-1.60.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-nghttp2-1.63.0-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.6.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp3-1.5.0-1-any.pkg.tar.zst";
-  sha256 = "1racc7cyzj22kink9w8m8jv73ji5hfg6r6d1ka9dqmvcbx04r8p0";
+  sha256 = "1ljl9kdasf91bxkqcmbbjchp5g00ahv8jn2zab38899z6j3x43nz";
-  name = "mingw-w64-clang-x86_64-curl-8.6.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-nghttp3-1.5.0-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.76.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-curl-8.9.1-2-any.pkg.tar.zst";
-  sha256 = "0ny3bvwvn5wmqrxzhdfw34akr0kj0m7rg9lg3w5yibqz2mkqhk11";
+  sha256 = "1zr6kgqp9i4qqrfckh3kfmz4x1cwv4xis9sfqsx7xji88priax64";
-  name = "mingw-w64-clang-x86_64-rust-1.76.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-curl-8.9.1-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.1.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rust-1.80.1-1-any.pkg.tar.zst";
-  sha256 = "00kxqg9ds4q74lxrzjh8z0858smqbi1j9r06s0zjadsql0ln98cq";
+  sha256 = "1dm4vlrfi9m6xl09zpn0yjr7qcjjr4x738z1rjfwysfnc0awq4x8";
-  name = "mingw-w64-clang-x86_64-pkgconf-12.1.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-rust-1.80.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cppdap-1.65-1-any.pkg.tar.zst";
-  sha256 = "0kj1vzjh3qh7d2g47avlgk7a6j4nc62111hy1m63jwq0alc01k38";
+  sha256 = "0phhwkcqp30dsyj5vr6w99sgm1jfm5rzg0w5x5mv9md4x7lm9lmh";
-  name = "mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-cppdap-1.65-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
  sha256 = "19xfl1q78q1k8j0lr5aspcf668pmfg01fgib73zq7ff7y5y5fcyi";
  name = "mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -223,9 +229,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lz4-1.9.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-lz4-1.10.0-1-any.pkg.tar.zst";
-  sha256 = "0nn7cy25j53q5ckkx4n4f77w00xdwwf5wjswm374shvvs58nlln0";
+  sha256 = "0kznnw9z9zqxkmn8qbypm2rpsfaapbgls1ks3zzpfnfjz9cpw8py";
-  name = "mingw-w64-clang-x86_64-lz4-1.9.4-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-lz4-1.10.0-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -241,9 +247,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libarchive-3.7.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libarchive-3.7.4-1-any.pkg.tar.zst";
-  sha256 = "1p84yh6yzkdpmr02vyvgz16x5gycckah25jkdc2py09l7iw96bmw";
+  sha256 = "1ykw6imllgxv6lsgwxx1miqjr4l1iryqkrj286jcbfrb8ghpzhv5";
-  name = "mingw-w64-clang-x86_64-libarchive-3.7.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libarchive-3.7.4-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -253,9 +259,15 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ninja-1.11.1-3-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-ninja-1.12.1-1-any.pkg.tar.zst";
-  sha256 = "13wjfmyfr952n3ydpldjlwx1nla5xpyvr96ng8pfbyw4z900v5ms";
+  sha256 = "1vj9qaa43v316daz8k4ricmz3f33nhjpj7r0vn979nwmy7hzs7jx";
-  name = "mingw-w64-clang-x86_64-ninja-1.11.1-3-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-ninja-1.12.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-pkgconf-1~2.3.0-1-any.pkg.tar.zst";
  sha256 = "15i7x6akkgs7aa7aa804k93p2iipnvygsy7z8hsafskka3h150fa";
  name = "mingw-w64-clang-x86_64-pkgconf-12.3.0-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -265,9 +277,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.29.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.30.3-1-any.pkg.tar.zst";
-  sha256 = "0l79lf6zihn0k8hz93qnjnq259y45yq19235g9c444jc2w093si1";
+  sha256 = "0fjwf6xxzli6rcsbzr1razldmm538ibkyf5kw132lpaz5wma9bj8";
-  name = "mingw-w64-clang-x86_64-cmake-3.29.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-cmake-3.30.3-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -289,9 +301,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-readline-8.2.013-1-any.pkg.tar.zst";
-  sha256 = "1s47pd5iz8y3hspsxn4pnp0v3m05ccia40v5nfvx0rmwgvcaz82v";
+  sha256 = "0pv1ypqfgm4mimzr0amq9anr1ysqmzrwv6gfk7rrlzhihadknsvr";
-  name = "mingw-w64-clang-x86_64-readline-8.2.010-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-readline-8.2.013-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -301,15 +313,15 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.45.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.46.1-1-any.pkg.tar.zst";
-  sha256 = "1icvw3f08cgi94p0177i46v72wgpsxw95p6kd0sm2w3vj0qlqbcw";
+  sha256 = "1axplxyjnaz411qzjjqwbj55fbrh4akq3plm2p1sx64jp844xpyq";
-  name = "mingw-w64-clang-x86_64-sqlite3-3.45.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-sqlite3-3.46.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tk-8.6.12-2-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-tk-8.6.13-1-any.pkg.tar.zst";
-  sha256 = "0pi74q91vl6vw8vvmmwnvrgai3b1aanp0zhca5qsmv8ljh2wdgzx";
+  sha256 = "12f6lqx1sglczcnz2ns6sxw9cxwm1klxajqzcrbnfwln1nllz2nd";
-  name = "mingw-w64-clang-x86_64-tk-8.6.12-2-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-tk-8.6.13-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -319,32 +331,38 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-3.11.8-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python3.12-3.12.1-2-any.pkg.tar.zst";
-  sha256 = "0djpf4k8s25nys6nrm2x2v134lcgzhhbjs37ihkg0b3sxmmc3b0p";
+  sha256 = "0wmd39wl9z237w093a7c6hl5pclca9yvwxn0kiw6i2njk3sjv51a";
-  name = "mingw-w64-clang-x86_64-python-3.11.8-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-python3.12-3.12.1-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openmp-18.1.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-3.11.9-1-any.pkg.tar.zst";
-  sha256 = "1v9wm3ja3a7a7yna2bpqky481qf244wc98kfdl7l03k7rkvvydpl";
+  sha256 = "0ah1idjqxg7jc07a1gz9z766rjjd0f0c6ri4hpcsimsrbj1zjd3c";
-  name = "mingw-w64-clang-x86_64-openmp-18.1.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-python-3.11.9-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.26-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-llvm-openmp-18.1.8-1-any.pkg.tar.zst";
-  sha256 = "0kdr72y5lc9dl9s1bjrw8g21qmv2iwd1xvn1r21170i277wsmqiv";
+  sha256 = "0cy2v0l4af24j34mzj5q5nlzcqhackfajlfj1rpf6mb3rbz23qw9";
-  name = "mingw-w64-clang-x86_64-openblas-0.3.26-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-llvm-openmp-18.1.8-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.28-1-any.pkg.tar.zst";
-  sha256 = "00h0ap954cjwlsc3p01fjwy7s3nlzs90v0kmnrzxm0rljmvn4jkf";
+  sha256 = "1pskcqc1lg9p8m8rk7bw3mz7mn7vw5fpl7zxa23bhjn02p5b79qq";
-  name = "mingw-w64-clang-x86_64-python-numpy-1.26.4-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-openblas-0.3.28-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-69.1.1-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-numpy-2.0.1-1-any.pkg.tar.zst";
-  sha256 = "1mc56anasj0v92nlg84m3pa7dbqgjakxw0b4ibqlrr9cq0xzsg4b";
+  sha256 = "0ks6q8v58h4wmr2pzsjl2xm4f63g0psvfm0jwlz24mqfxp8gqfcc";
-  name = "mingw-w64-clang-x86_64-python-setuptools-69.1.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-python-numpy-2.0.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
  sha256 = "0xc95z5jzzjf5lw35bs4yn5rlwkrkmrh78yi5rranqpz5nn0wsa0";
  name = "mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
 })
 ]
Author	SHA1	Message	Date
Sébastien Bourdeauducq	6c8382219f	msys2: get python via numpy dependencies	2024-09-30 14:27:30 +08:00
Sebastien Bourdeauducq	9274a7b96b	flake: update nixpkgs	2024-09-30 14:22:40 +08:00
Sébastien Bourdeauducq	d1c0fe2900	cargo: update dependencies	2024-09-30 14:14:43 +08:00
mwojcik	f2c047ba57	artiq: support async rpcs Co-authored-by: mwojcik <mw@m-labs.hk> Co-committed-by: mwojcik <mw@m-labs.hk>	2024-09-13 12:12:13 +08:00
David Mak	5e2e77a500	[meta] Bump inkwell to v0.5	2024-09-13 11:11:14 +08:00
David Mak	f3cc4702b9	[meta] Update dependencies	2024-09-13 11:11:14 +08:00
David Mak	3e92c491f5	[standalone] Add tests creating ndarrays with tuple dims	2024-09-11 15:52:43 +08:00
lyken	7f629f1579	core: fix comment in unify_call	2024-09-11 15:46:19 +08:00
lyken	5640a793e2	core: allow np_full to take tuple shapes	2024-09-11 15:46:19 +08:00
David Mak	abbaa506ad	[standalone] Remove redundant recreation of TargetMachine	2024-09-09 14:27:10 +08:00
David Mak	f3dc02d646	[meta] Apply cargo fmt	2024-09-09 14:24:52 +08:00
David Mak	ea217eaea1	[meta] Update pre-commit config Directly invoke cargo using nix develop to avoid using the system cargo.	2024-09-09 14:24:38 +08:00
Sébastien Bourdeauducq	5a34551905	allow the use of the LLVM shared library Which in turns allows working around the incompatibility of the LLVM static library with Rust link-args=-rdynamic, which produces binaries that either fail to link (OpenBSD) or segfault on startup (Linux). The year is 2024 and compiler toolchains are still a trash fire like this.	2024-09-09 11:17:31 +08:00
Sebastien Bourdeauducq	6098b1b853	fix previous commit	2024-09-06 11:32:08 +08:00
Sebastien Bourdeauducq	668ccb1c95	nac3core: expose inkwell and nac3parser	2024-09-06 11:06:26 +08:00
Sebastien Bourdeauducq	a3c624d69d	update all dependencies	2024-09-06 10:21:58 +08:00
Sébastien Bourdeauducq	bd06155f34	irrt: compatibility with pre-C23 compilers	2024-09-05 18:54:55 +08:00
David Mak	9c33c4209c	[core] Fix type of ndarray.element_type Should be the element type of the NDArray itself, not the pointer to its type.	2024-08-30 22:47:38 +08:00
Sebastien Bourdeauducq	122983f11c	flake: update dependencies	2024-08-30 14:45:38 +08:00
David Mak	71c3a65a31	[core] codegen/stmt: Fix obtaining return type of sret functions	2024-08-29 19:15:30 +08:00
David Mak	8c540d1033	[core] codegen/stmt: Add more casts for boolean types	2024-08-29 16:36:32 +08:00
David Mak	0cc60a3d33	[core] codegen/expr: Fix missing cast to i1	2024-08-29 16:36:32 +08:00
David Mak	a59c26aa99	[artiq] Fix RPC of ndarrays from host	2024-08-29 16:08:45 +08:00
David Mak	02d93b11d1	[meta] Update dependencies	2024-08-29 14:32:21 +08:00
lyken	59cad5bfe1	standalone: clang-format demo.c	2024-08-29 10:37:24 +08:00
lyken	4318f8de84	standalone: improve src/assignment.py	2024-08-29 10:33:58 +08:00
David Mak	15ac00708a	[core] Use quoted include paths instead of angled brackets This is preferred for user-defined headers.	2024-08-28 16:37:03 +08:00
lyken	c8dfdcfdea	standalone & artiq: remove class_names from resolver	2024-08-27 23:43:40 +08:00
Sébastien Bourdeauducq	600a5c8679	Revert "standalone: reformat demo.c" This reverts commit `308edb8237`.	2024-08-27 23:06:49 +08:00
lyken	22c4d25802	core/typecheck: add missing typecheck in matmul	2024-08-27 22:59:39 +08:00
lyken	308edb8237	standalone: reformat demo.c	2024-08-27 22:55:22 +08:00
lyken	9848795dcc	core/irrt: add exceptions and debug utils	2024-08-27 22:55:22 +08:00
lyken	58222feed4	core/irrt: split into headers	2024-08-27 22:55:22 +08:00
lyken	518f21d174	core/irrt: build.rs capture IR defined constants	2024-08-27 22:55:22 +08:00
lyken	e8e49684bf	core/irrt: build.rs capture IR defined types	2024-08-27 22:55:22 +08:00
lyken	b2900b4883	core/irrt: use +std=c++20 to compile To explicitly set the C++ variant and avoid inconsistencies.	2024-08-27 22:55:22 +08:00
lyken	c6dade1394	core/irrt: reformat	2024-08-27 22:55:22 +08:00
lyken	7e3fcc0845	add .clang-format	2024-08-27 22:55:22 +08:00
lyken	d3b4c60d7f	core/irrt: comment build.rs & move irrt to nac3core/irrt	2024-08-27 22:55:22 +08:00
abdul124	5b2b6db7ed	core: improve error messages	2024-08-26 18:37:55 +08:00
abdul124	15e62f467e	standalone: add tests for polymorphism	2024-08-26 18:37:55 +08:00
abdul124	2c88924ff7	core: add support for simple polymorphism	2024-08-26 18:37:55 +08:00
abdul124	a744b139ba	core: allow Call and AnnAssign in init block	2024-08-26 18:37:55 +08:00
David Mak	2b2b2dbf8f	[core] Fix resolution of exception names in raise short form Previous implementation fails as `resolver.get_identifier_def` in ARTIQ would return the exception __init__ function rather than the class. We fix this by limiting the exception class resolution to only include raise statements, and to force the exception name to always be treated as a class. Fixes #501.	2024-08-26 18:35:02 +08:00
David Mak	d9f96dab33	[core] Add codegen_unreachable	2024-08-23 13:10:55 +08:00
David Mak	c5ae0e7c36	[standalone] Add tests for tuple equality	2024-08-21 16:25:32 +08:00
David Mak	b8dab6cf7c	[standalone] Add tests for string equality	2024-08-21 16:25:32 +08:00
David Mak	4d80ba38b7	[core] codegen/expr: Implement comparison of tuples	2024-08-21 16:25:32 +08:00
David Mak	33929bda24	[core] typecheck/typedef: Add support for tuple methods	2024-08-21 16:25:32 +08:00
David Mak	a8e92212c0	[core] codegen/expr: Implement string equality	2024-08-21 16:25:32 +08:00
David Mak	908271014a	[core] typecheck/magic_methods: Add equality methods to string	2024-08-21 16:25:32 +08:00
David Mak	c407622f5c	[core] codegen/expr: Add compilation error for unsupported cmpop	2024-08-21 15:46:13 +08:00
David Mak	d7952d0629	[core] codegen/expr: Fix assertions not generated for -O0	2024-08-21 15:36:54 +08:00
David Mak	ca1395aed6	[core] codegen: Remove redundant return	2024-08-21 15:36:54 +08:00
David Mak	7799aa4987	[meta] Do not specify rev in dependency version	2024-08-21 15:36:54 +08:00
David Mak	76016a26ad	[meta] Apply clippy suggestions	2024-08-21 13:07:57 +08:00
lyken	8532bf5206	standalone: add missing test_ndarray_ceil() run	2024-08-21 11:39:00 +08:00
lyken	2cf64d8608	apply clippy comment changes	2024-08-21 11:21:10 +08:00
lyken	706759adb2	artiq: apply cargo fmt	2024-08-21 11:21:10 +08:00
lyken	b90cf2300b	core/fix: add missing lifetime in gen_for*	2024-08-21 11:05:30 +08:00
Sebastien Bourdeauducq	0fc26df29e	flake: update nixpkgs	2024-08-19 23:53:15 +08:00
David Mak	0b074c2cf2	[artiq] symbol_resolver: Set private linkage for constants	2024-08-19 14:41:43 +08:00
Sébastien Bourdeauducq	a0f6961e0e	cargo: update dependencies	2024-08-19 13:15:03 +08:00
David Mak	b1c5c2e1d4	[artiq] Fix RPC of ndarrays to host	2024-08-15 15:41:24 +08:00
David Mak	69320a6cf1	[artiq] Fix LLVM representation of strings Should be `%str` rather than `[N x i8]`.	2024-08-14 09:30:08 +08:00
David Mak	9e0601837a	core: Add compile-time feature to disable escape analysis	2024-08-14 09:29:48 +08:00
lyken	432c81a500	core: update insta after #489	2024-08-13 15:30:34 +08:00
David Mak	6beff7a268	[artiq] Implement core_log and rtio_log in terms of polymorphic_print Implementation mostly references the original implementation in Python.	2024-08-13 15:19:03 +08:00
David Mak	6ca7aecd4a	[artiq] Add core_log and rtio_log function declarations	2024-08-13 15:19:03 +08:00
David Mak	8fd7216243	[core] toplevel/composer: Add lateinit_builtins This is required for the new core_log and rtio_log functions, which take a generic type as its parameter. However, in ARTIQ builtins are initialized using one unifier and then actually used by another unifier. lateinit_builtins workaround this issue by deferring the initialization of functions requiring type variables until the actual unifier is ready.	2024-08-13 15:19:03 +08:00
David Mak	4f5e417012	[core] codegen: Add function to get format constants for integers	2024-08-13 15:19:03 +08:00
David Mak	a0614bad83	[core] codegen/expr: Make gen_string return `StructValue` So that it is clear that the value itself is returned rather than a pointer to the struct or its data.	2024-08-13 15:19:03 +08:00
David Mak	5539d144ed	[core] Add `CodeGenContext::build_in_bounds_gep_and_load` For safer accesses to `gep`-able values and faster fails.	2024-08-13 15:19:03 +08:00
David Mak	b3891b9a0d	standalone: Fix several issues post script refactoring - Add helptext for check_demos.sh - Add back support for using debug NAC3 for running tests - Output error message when argument is not recognized - Fixed last non-demo script argument being ignored - Add back SSE2 requirement to NAC3 (required for mandelbrot)	2024-08-13 15:19:03 +08:00
David Mak	6fb8939179	[meta] Update dependencies	2024-08-13 15:19:03 +08:00
lyken	973dc5041a	core/typecheck: Support tuple arg type in len()	2024-08-13 15:02:59 +08:00
David Mak	d0da688aa7	standalone: Add tuple len test	2024-08-13 15:02:59 +08:00
David Mak	12c4e1cf48	core/toplevel/builtins: Add support for len() on tuples	2024-08-13 15:02:59 +08:00
David Mak	9b988647ed	core/toplevel/builtins: Extract len() into builtin function	2024-08-13 15:02:59 +08:00
lyken	35a7cecc12	core/typecheck: fix np_array ndmin bug	2024-08-13 12:50:04 +08:00
lyken	7e3d87f841	core/codegen: fix bug in call_ceil function	2024-08-07 16:40:55 +08:00
David Mak	ac0d83ef98	standalone: Add vararg.py	2024-08-06 11:48:42 +08:00
David Mak	3ff6db1a29	core/codegen: Add va_start and va_end intrinsics	2024-08-06 11:48:42 +08:00
David Mak	d7b806afb4	core/codegen: Implement support for va_info on supported architectures	2024-08-06 11:48:40 +08:00
David Mak	fac60c3974	core/codegen: Handle vararg in function generation	2024-08-06 11:46:00 +08:00
David Mak	f5fb504a15	core/codegen/expr: Implement vararg handling in gen_call	2024-08-06 11:46:00 +08:00
David Mak	faa3bb97ad	core/typecheck/typedef: Add vararg to Unifier::stringify	2024-08-06 11:46:00 +08:00
David Mak	6a64c9d1de	core/typecheck/typedef: Add is_vararg_ctx to TTuple	2024-08-06 11:45:54 +08:00
David Mak	3dc8498202	core/typecheck/typedef: Handle vararg parameters in unify_call	2024-08-06 11:43:13 +08:00
David Mak	cbf79c5e9c	core/typecheck/typedef: Add is_vararg to FuncArg, ConcreteFuncArg	2024-08-06 11:43:13 +08:00
David Mak	b8aa17bf8c	core/toplevel/composer: Add parsing for vararg parameter	2024-08-06 10:52:24 +08:00
David Mak	f5b998cd9c	core/codegen: Remove unnecessary mut from get_llvm*_type	2024-08-06 10:52:24 +08:00
David Mak	c36f85ecb9	meta: Update dependencies	2024-08-06 10:52:24 +08:00
lyken	3a8c385e01	core/typecheck: fix missing ExprKind::Asterisk in fix_assignment_target_context	2024-08-05 19:30:48 +08:00
lyken	221de4d06a	core/codegen: add missing comment	2024-08-05 19:30:48 +08:00
lyken	fb9fe8edf2	core: reimplement assignment type inference and codegen - distinguish between setitem and getitem - allow starred assignment targets, but the assigned value would be a tuple - allow both [...] and (...) to be target lists	2024-08-05 19:30:48 +08:00
lyken	894083c6a3	core/codegen: refactor gen_{for,comprehension} to match on iter type	2024-08-05 19:30:48 +08:00
Sébastien Bourdeauducq	669c6aca6b	clean up and fix 32-bit demos	2024-08-05 19:04:25 +08:00
abdul124	63d2b49b09	core: remove np_linalg_matmul	2024-08-05 11:44:55 +08:00
abdul124	bf709889c4	standalone/demo: separate linalg functions from main workspace	2024-08-05 11:44:54 +08:00
abdul124	1c72698d02	core: add np_linalg_det and np_linalg_matrix_power functions	2024-07-31 18:02:54 +08:00
abdul124	54f883f0a5	core: implement np_dot using LLVM_IR	2024-07-31 15:53:51 +08:00
abdul124	4a6845dac6	standalone: add np.transpose and np.reshape functions	2024-07-31 13:23:07 +08:00
abdul124	00236f48bc	core: add np.transpose and np.reshape functions	2024-07-31 13:23:07 +08:00
abdul124	a3e6bb2292	core/helper: add linalg section	2024-07-31 13:23:07 +08:00
abdul124	17171065b1	standalone: link linalg at runtime	2024-07-31 13:23:07 +08:00
abdul124	540b35ec84	standalone: move linalg functions to demo	2024-07-31 13:23:05 +08:00
abdul124	4bb00c52e3	core/builtin_fns: improve error reporting	2024-07-31 13:21:31 +08:00
abdul124	faf07527cb	standalone: add runtime implementation for linalg functions	2024-07-31 13:21:28 +08:00
abdul124	d6a4d0a634	standalone: add linalg methods and tests	2024-07-29 16:48:06 +08:00
abdul124	2242c5af43	core: add linalg methods	2024-07-29 16:48:06 +08:00
David Mak	318a675ea6	standalone: Rename -m32 to -i386	2024-07-29 14:58:58 +08:00
David Mak	32e52ce198	standalone: Revert using uint32_t as slice length Turns out list and str have always been size_t.	2024-07-29 14:58:29 +08:00
Sebastien Bourdeauducq	665ca8e32d	cargo: update dependencies	2024-07-27 22:24:56 +08:00
Sebastien Bourdeauducq	12c12b1d80	flake: update nixpkgs	2024-07-27 22:22:20 +08:00
lyken	72972fa909	core/toplevel: add more numpy categories	2024-07-27 21:57:47 +08:00
lyken	142cd48594	core/toplevel: reorder PrimDef::details	2024-07-27 21:57:47 +08:00
lyken	8adfe781c5	core/toplevel: fix PrimDef method names	2024-07-27 21:57:47 +08:00
lyken	339b74161b	core/toplevel: reorganize PrimDef	2024-07-27 21:57:47 +08:00
David Mak	8c5ba37d09	standalone: Add 32-bit execution tests to check_demo.sh	2024-07-26 13:35:40 +08:00
David Mak	05a8948ff2	core: Minor cleanup to use ListValue APIs	2024-07-26 13:35:40 +08:00
David Mak	6d171ec284	core: Add label name and hooks to gen_for functions	2024-07-26 13:35:40 +08:00
David Mak	0ba68f6657	core: Set target triple and datalayout for each module Fixes an issue with inconsistent pointer sizes causing crashes.	2024-07-26 13:35:40 +08:00
David Mak	693b2a8863	core: Add support for 32-bit size_t on 64-bit targets	2024-07-26 13:35:40 +08:00
David Mak	5faeede0e5	Determine size_t using LLVM target machine	2024-07-26 13:35:38 +08:00
David Mak	266707df9d	standalone: Add support for running 32-bit binaries	2024-07-26 13:32:38 +08:00
David Mak	3d3c258756	standalone: Remove support for --lli	2024-07-26 13:32:38 +08:00
David Mak	ed1182cb24	standalone: Update format specifiers for exceptions Use platform-agnostic identifiers instead.	2024-07-26 13:32:37 +08:00
David Mak	fd025c1137	standalone: Use uint32_t for cslice length Matching the expected type of string and list slices.	2024-07-26 13:32:21 +08:00
David Mak	f139db9af9	meta: Update dependencies	2024-07-26 10:33:02 +08:00
lyken	44487b76ae	standalone: interpret_demo.py remove duplicated section	2024-07-22 17:23:35 +08:00
lyken	1332f113e8	standalone: fix interpret_demo.py comments	2024-07-22 17:06:14 +08:00
Sébastien Bourdeauducq	7632d6f72a	cargo: update dependencies	2024-07-21 11:00:25 +08:00
David Mak	4948395ca2	core/toplevel/type_annotation: Add handling for mismatching class def Primitive types only contain fields in its Type and not its TopLevelDef. This causes primitive object types to lack some fields.	2024-07-19 14:42:14 +08:00
David Mak	3db3061d99	artiq/symbol_resolver: Handle type of zero-length lists	2024-07-19 14:42:14 +08:00
David Mak	51c2175c80	core/codegen/stmt: Convert assertion values to i1	2024-07-19 14:42:14 +08:00
lyken	1a31a50b8a	standalone: fix __nac3_raise def in demo.c	2024-07-17 21:22:08 +08:00
lyken	6c10e3d056	core: cargo clippy	2024-07-12 21:18:53 +08:00
lyken	2dbc1ec659	cargo fmt	2024-07-12 21:16:38 +08:00
Sebastien Bourdeauducq	c80378063a	add np_argmin/argmax to interpret_demo environment	2024-07-12 13:27:52 +02:00
abdul124	513d30152b	core: support raise exception short form	2024-07-12 18:58:34 +08:00
abdul124	45e9360c4d	standalone: Add np_argmax and np_argmin tests	2024-07-12 18:19:56 +08:00
abdul124	2e01b77fc8	core: refactor np_max/np_min functions	2024-07-12 18:18:54 +08:00
abdul124	cea7cade51	core: add np_argmax/np_argmin functions	2024-07-12 18:18:28 +08:00
Sebastien Bourdeauducq	d658d9b00e	update dependencies, Python 3.12 on Linux	2024-07-09 23:56:12 +08:00
abdul124	eeb474f9e6	core: reduce code duplication in codegen/extern_fns (#453 ) Used macros to reduce code duplication in `codegen/extern_fns` Reviewed-on: #453 Co-authored-by: abdul124 <ar@m-labs.hk> Co-committed-by: abdul124 <ar@m-labs.hk>	2024-07-09 16:31:08 +08:00
abdul124	88b72af2d1	core/llvm_intrinsic: improve macro name and comments	2024-07-09 16:30:32 +08:00
abdul124	b73f6c4d68	core: reduce code duplication in codegen/llvm_intrinsic	2024-07-09 16:30:32 +08:00
David Mak	f47cdec650	standalone: Fix output format of output_range	2024-07-09 13:55:48 +08:00
David Mak	d656880e44	standalone: Fix missing implementation for output_range	2024-07-09 13:53:50 +08:00
David Mak	a91602915a	core: Fix missing fields in range type	2024-07-09 13:53:50 +08:00
David Mak	1c56005a01	core: Reformat and modernize irrt.cpp - Use anon namespace instead of static - Use using declaration instead of typedef - Align pointers to the type instead of the identifier	2024-07-09 13:53:50 +08:00
David Mak	bc40a32524	core: Add report_type_error to enable more code reuse	2024-07-09 13:44:47 +08:00
David Mak	c820daf5f8	core: Apply cargo format	2024-07-09 13:32:10 +08:00
David Mak	25d2de67f7	standalone: Add output_range and tests	2024-07-09 04:44:40 +08:00
David Mak	2cfb7a7e10	core: Refactor range function into constructor	2024-07-09 04:44:40 +08:00
David Mak	9238a5e86e	standalone: Rename output_str to output_strln and add output_str output_str is for outputting strings without newline, and the newly introduced output_strln now has the old behavior of ending with a newline.	2024-07-09 04:44:40 +08:00
lyken	76defac462	meta: use clang -x c++ instead of clang++	2024-07-07 20:03:34 +08:00
lyken	650f354b74	core: use C++ for irrt source	2024-07-07 14:36:10 +08:00
abdul124	f062ef5f59	core/llvm_intrinsic: replace roundeven with rint	2024-07-07 14:24:18 +08:00
lyken	f52086b706	core: improve binop and cmpop error messages	2024-07-05 16:27:24 +08:00
lyken	0a732691c9	core: refactor typecheck/magic_methods.rs operators & add op symbol name	2024-07-05 16:27:20 +08:00
lyken	cbff356d50	core: workaround inkwell on `llvm.stackrestore`	2024-07-05 13:56:12 +08:00
lyken	24ac3820b2	core: check int32 obj_id directly in fold_numpy_function_call_shape_argument	2024-07-05 10:36:47 +08:00
David Mak	ba32fab374	standalone: Add demos for list arithmetic operators	2024-07-04 16:01:15 +08:00
David Mak	c4052b6342	core: Implement multi-operand __eq__ and __ne__ for lists	2024-07-04 16:01:15 +08:00
David Mak	66c205275f	core: Implement list::__add__	2024-07-04 16:01:11 +08:00
David Mak	c85e412206	core: Implement list::__mul__	2024-07-04 15:53:50 +08:00
David Mak	075536d7bd	core: Add BreakContinueHooks for gen_for_callback	2024-07-04 15:32:18 +08:00
David Mak	13beeaa2bf	core: Implement handling for zero-length lists	2024-07-04 15:32:18 +08:00
David Mak	2194dbddd5	core/type_annotation: Refactor List type to TObj In preparation for operators on lists.	2024-07-04 15:32:18 +08:00
David Mak	94a1d547d6	meta: Update dependencies	2024-07-04 15:32:18 +08:00
lyken	d6565feed3	core: ndarray_from_ndlist_impl cast size_of to usize	2024-07-04 12:24:52 +08:00
abdul124	83154ef8e1	core/llvm_intrinsics: remove llvm.roundeven call from call_float_roundeven	2024-07-03 14:17:47 +08:00
lyken	0744b938b8	core: fix __nac3_ndarray_calc_size crash due to incorrect typing	2024-07-03 13:03:14 +08:00
lyken	56fa2b6803	core: fix crash on iterating over non-iterables a	2024-06-28 15:45:53 +08:00
lyken	d06c13f936	core: fix crash on invalid subscripting	2024-06-27 16:58:48 +08:00
lyken	9808923258	core: improve comments in type_inferencer/mod.rs	2024-06-27 14:46:48 +08:00
lyken	5b11a1dbdd	core: support tuple and int32 input for np_empty, np_ones, and more	2024-06-27 14:30:17 +08:00
lyken	b21df53e0d	core: fix comment typo in unify_call()	2024-06-27 14:06:39 +08:00
lyken	0ec967a468	core: improve function call errors	2024-06-27 14:06:39 +08:00
lyken	ca8459dc7b	standalone: prettify TopLevelComposer error reporting	2024-06-27 10:15:14 +08:00
abdul124	b0b804051a	nac3artiq: allow class attribute access without init function	2024-06-25 16:06:33 +08:00
abdul124	134af79fd6	core: add support for class attributes	2024-06-25 16:06:33 +08:00
abdul124	7fe2c3496c	core: add attribute field to class definition	2024-06-25 16:06:33 +08:00