binop: expand `not` operator as loglcal not

[ast] Refactor lazy_static to LazyLock
It is available in Rust 1.80 and reduces a dependency.
2024-11-08 17:12:01 +08:00 · 2024-10-30 12:29:51 +08:00 · 2024-10-30 12:29:51 +08:00 · 2024-10-18 14:17:16 +08:00 · 2024-10-18 14:16:42 +08:00 · 2024-10-17 16:25:52 +08:00
95 changed files with 9095 additions and 3125 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.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "23a1e53f0f5d86382dafe1cf314783b2044280f406e7e1506368220ad11b1338"
 dependencies = [
 "anstyle",
 "anstyle-parse",
@ -41,67 +41,67 @@ dependencies = [
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "8365de52b16c035ff4fcafe0092ba9390540e3e352870ac09933bebcaa2c8c56"
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
 dependencies = [
 "utf8parse",
 ]
 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
 dependencies = [
 "anstyle",
- "windows-sys",
+ "windows-sys 0.59.0",
 ]
 [[package]]
 name = "ascii-canvas"
-version = "3.0.0"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6"
+checksum = "ef1e3e699d84ab1b0911a1010c5c106aa34ae89aeac103be5ce0c3859db1e891"
 dependencies = [
 "term",
 ]
 [[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.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
 dependencies = [
 "bit-vec",
 ]
 [[package]]
 name = "bit-vec"
-version = "0.6.3"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 [[package]]
 name = "bitflags"
@ -109,6 +109,15 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 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"
 version = "1.5.0"
@ -117,9 +126,12 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "cc"
-version = "1.1.0"
+version = "1.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaff6f8ce506b9773fa786672d63fc7a191ffea1be33f72bbd4aeacefca9ffc8"
+checksum = "c2e7962b54006dcfcc61cb72735f4d89bb97061dd6a7ed882ec6b8ee53714c6f"
 dependencies = [
 "shlex",
 ]
 [[package]]
 name = "cfg-if"
@ -129,9 +141,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -139,9 +151,9 @@ dependencies = [
 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
 "anstream",
 "anstyle",
@ -151,27 +163,27 @@ dependencies = [
 [[package]]
 name = "clap_derive"
-version = "4.5.8"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
+checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[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.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 [[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,30 +263,23 @@ 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"
 [[package]]
 name = "dirs-next"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
 dependencies = [
- "cfg-if",
+ "generic-array",
- "dirs-sys-next",
+ "typenum",
 ]
 [[package]]
-name = "dirs-sys-next"
+name = "digest"
-version = "0.1.2"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
- "libc",
+ "block-buffer",
- "redox_users",
+ "crypto-common",
 "winapi",
 ]
 [[package]]
@ -302,14 +316,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 +340,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"
@ -361,6 +385,12 @@ dependencies = [
 "ahash",
 ]
 [[package]]
 name = "hashbrown"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb"
 [[package]]
 name = "heck"
 version = "0.4.1"
@ -373,6 +403,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "home"
 version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
 "windows-sys 0.52.0",
 ]
 [[package]]
 name = "indexmap"
 version = "1.9.3"
@ -385,12 +424,12 @@ dependencies = [
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
 "equivalent",
- "hashbrown 0.14.5",
+ "hashbrown 0.15.0",
 ]
 [[package]]
@ -401,9 +440,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 +454,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.70",
+ "syn 2.0.85",
 ]
 [[package]]
@ -440,18 +479,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,34 +499,44 @@ 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.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06093b57658c723a21da679530e061a8c25340fa5a6f98e313b542268c7e2a1f"
 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.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507460a910eb7b32ee961886ff48539633b788a36b65692b95f225b844c82553"
+checksum = "feee752d43abd0f4807a921958ab4131f692a44d4d599733d4419c5d586176ce"
 dependencies = [
 "regex-automata",
 "rustversion",
 ]
 [[package]]
@ -507,30 +547,20 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.161"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "8e9489c2807c139ffd9c1794f4af0ebe86a828db53ecdc7fea2111d0fed085d1"
 [[package]]
 name = "libloading"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
 "cfg-if",
 "windows-targets",
 ]
 [[package]]
 name = "libredox"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
 "bitflags",
 "libc",
 ]
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@ -591,11 +621,9 @@ dependencies = [
 name = "nac3artiq"
 version = "0.1.0"
 dependencies = [
- "inkwell",
+ "itertools",
 "itertools 0.13.0",
 "nac3core",
 "nac3ld",
 "nac3parser",
 "parking_lot",
 "pyo3",
 "tempfile",
@ -606,7 +634,6 @@ name = "nac3ast"
 version = "0.1.0"
 dependencies = [
 "fxhash",
 "lazy_static",
 "parking_lot",
 "string-interner",
 ]
@ -616,11 +643,11 @@ name = "nac3core"
 version = "0.1.0"
 dependencies = [
 "crossbeam",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
 "indoc",
 "inkwell",
 "insta",
- "itertools 0.13.0",
+ "itertools",
 "nac3parser",
 "parking_lot",
 "rayon",
@ -658,9 +685,7 @@ name = "nac3standalone"
 version = "0.1.0"
 dependencies = [
 "clap",
 "inkwell",
 "nac3core",
 "nac3parser",
 "parking_lot",
 ]
@ -672,9 +697,9 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 [[package]]
 name = "once_cell"
-version = "1.19.0"
+version = "1.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775"
 [[package]]
 name = "parking_lot"
@ -706,7 +731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
 "fixedbitset",
- "indexmap 2.2.6",
+ "indexmap 2.6.0",
 ]
 [[package]]
@ -749,7 +774,7 @@ dependencies = [
 "phf_shared 0.11.2",
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[package]]
@ -778,15 +803,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 +824,9 @@ checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
 "unicode-ident",
 ]
@ -850,7 +878,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[package]]
@ -863,14 +891,14 @@ dependencies = [
 "proc-macro2",
 "pyo3-build-config",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[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,29 +955,18 @@ dependencies = [
 [[package]]
 name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "9b6dfecf2c74bce2466cabf93f6664d6998a69eb21e39f4207930065b27b771f"
 dependencies = [
 "bitflags",
 ]
 [[package]]
 name = "redox_users"
 version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
 "getrandom",
 "libredox",
 "thiserror",
 ]
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
 "aho-corasick",
 "memchr",
@ -959,9 +976,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 +987,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,22 +1000,22 @@ dependencies = [
 [[package]]
 name = "rustix"
-version = "0.38.34"
+version = "0.38.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+checksum = "aa260229e6538e52293eeb577aabd09945a09d6d9cc0fc550ed7529056c2e32a"
 dependencies = [
 "bitflags",
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 [[package]]
 name = "rustversion"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
 [[package]]
 name = "ryu"
@ -1029,31 +1046,32 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
 "serde_derive",
 ]
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[package]]
 name = "serde_json"
-version = "1.0.120"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
 "itoa",
 "memchr",
 "ryu",
 "serde",
 ]
@ -1071,10 +1089,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"
@ -1134,7 +1168,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[package]]
@ -1150,9 +1184,9 @@ dependencies = [
 [[package]]
 name = "syn"
-version = "2.0.70"
+version = "2.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0209b68b3613b093e0ec905354eccaedcfe83b8cb37cbdeae64026c3064c16"
+checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1161,31 +1195,31 @@ dependencies = [
 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+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]]
 name = "term"
-version = "0.7.0"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+checksum = "4df4175de05129f31b80458c6df371a15e7fc3fd367272e6bf938e5c351c7ea0"
 dependencies = [
- "dirs-next",
+ "home",
- "rustversion",
+ "windows-sys 0.52.0",
 "winapi",
 ]
 [[package]]
@ -1203,32 +1237,29 @@ dependencies = [
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "5d11abd9594d9b38965ef50805c5e469ca9cc6f197f883f717e0269a3057b3d5"
 dependencies = [
 "thiserror-impl",
 ]
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "ae71770322cbd277e69d762a16c444af02aa0575ac0d174f0b9562d3b37f8602"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
 [[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 +1315,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 +1343,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 +1367,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"
@ -1356,37 +1387,15 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 [[package]]
 name = "winapi"
 version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
 "winapi-i686-pc-windows-gnu",
 "winapi-x86_64-pc-windows-gnu",
 ]
 [[package]]
 name = "winapi-i686-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 [[package]]
 name = "winapi-util"
-version = "0.1.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]]
 name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@ -1396,6 +1405,15 @@ dependencies = [
 "windows-targets",
 ]
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
 "windows-targets",
 ]
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@ -1475,6 +1493,7 @@ version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
 "byteorder",
 "zerocopy-derive",
 ]
@ -1486,5 +1505,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.70",
+ "syn 2.0.85",
 ]
--- a/flake.lock
+++ b/flake.lock
@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1720418205,
+        "lastModified": 1727348695,
-        "narHash": "sha256-cPJoFPXU44GlhWg4pUk9oUPqurPlCFZ11ZQPk21GTPU=",
+        "narHash": "sha256-J+PeFKSDV+pHL7ukkfpVzCOO7mBSrrpJ3svwBFABbhI=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "655a58a72a6601292512670343087c2d75d859c1",
+        "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
@ -12,15 +12,10 @@ crate-type = ["cdylib"]
 itertools = "0.13"
 pyo3 = { version = "0.21", features = ["extension-module", "gil-refs"] }
 parking_lot = "0.12"
-tempfile = "3.10"
+tempfile = "3.13"
 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/src/codegen.rs
+++ b/nac3artiq/src/codegen.rs
--- a/nac3artiq/src/lib.rs
+++ b/nac3artiq/src/lib.rs
@ -16,63 +16,65 @@
    clippy::wildcard_imports
 )]
-use std::collections::{HashMap, HashSet};
+use std::{
-use std::fs;
+    collections::{HashMap, HashSet},
-use std::io::Write;
+    fs,
-use std::process::Command;
+    io::Write,
-use std::rc::Rc;
+    process::Command,
-use std::sync::Arc;
+    rc::Rc,
    sync::Arc,
 };
-use inkwell::{
+use itertools::Itertools;
 use parking_lot::{Mutex, RwLock};
 use pyo3::{
    create_exception, exceptions,
    prelude::*,
    types::{PyBytes, PyDict, PySet},
 };
 use tempfile::{self, TempDir};
 use nac3core::{
    codegen::{
        concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt, CodeGenLLVMOptions,
        CodeGenTargetMachineOptions, CodeGenTask, WithCall, WorkerRegistry,
    },
    inkwell::{
        context::Context,
        memory_buffer::MemoryBuffer,
        module::{Linkage, Module},
        passes::PassBuilderOptions,
        support::is_multithreaded,
        targets::*,
        OptimizationLevel,
-};
+    },
-use itertools::Itertools;
+    nac3parser::{
-use nac3core::codegen::{gen_func_impl, CodeGenLLVMOptions, CodeGenTargetMachineOptions};
+        ast::{Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
 use nac3core::toplevel::builtins::get_exn_constructor;
 use nac3core::typecheck::typedef::{TypeEnum, Unifier, VarMap};
 use nac3parser::{
    ast::{ExprKind, Stmt, StmtKind, StrRef},
        parser::parse_program,
-};
+    },
 use pyo3::create_exception;
 use pyo3::prelude::*;
 use pyo3::{exceptions, types::PyBytes, types::PyDict, types::PySet};
 use parking_lot::{Mutex, RwLock};
 use nac3core::{
    codegen::irrt::load_irrt,
    codegen::{concrete_type::ConcreteTypeStore, CodeGenTask, WithCall, WorkerRegistry},
    symbol_resolver::SymbolResolver,
    toplevel::{
-        composer::{ComposerConfig, TopLevelComposer},
+        builtins::get_exn_constructor,
        composer::{BuiltinFuncCreator, BuiltinFuncSpec, ComposerConfig, TopLevelComposer},
        DefinitionId, GenCall, TopLevelDef,
    },
-    typecheck::typedef::{FunSignature, FuncArg},
+    typecheck::{
-    typecheck::{type_inferencer::PrimitiveStore, typedef::Type},
+        type_inferencer::PrimitiveStore,
        typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
    },
 };
 use nac3ld::Linker;
-use tempfile::{self, TempDir};
+use codegen::{
-
+    attributes_writeback, gen_core_log, gen_rtio_log, rpc_codegen_callback, ArtiqCodeGenerator,
 use crate::codegen::attributes_writeback;
 use crate::{
    codegen::{rpc_codegen_callback, ArtiqCodeGenerator},
    symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver},
 };
 use symbol_resolver::{DeferredEvaluationStore, InnerResolver, PythonHelper, Resolver};
 use timeline::TimeFns;
 mod codegen;
 mod symbol_resolver;
 mod timeline;
 use timeline::TimeFns;
 #[derive(PartialEq, Clone, Copy)]
 enum Isa {
    Host,
@ -126,7 +128,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 +195,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 +209,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 +263,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 +299,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 +369,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 +446,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 +476,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 +502,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 +560,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 +576,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 +617,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 +633,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,
@ -566,6 +648,11 @@ impl Nac3 {
                            }
                        }
                    }
                    TopLevelDef::Variable { .. } => {
                        return Err(CompileError::new_err(String::from(
                            "Unsupported @rpc annotation on global variable",
                        )))
                    }
                }
            }
        }
@ -625,7 +712,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 +731,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 +754,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 +783,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 +869,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 +973,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 +989,7 @@ impl Nac3 {
                        name: "t".into(),
                        ty: primitive.int64,
                        default_value: None,
                        is_vararg: false,
                    }],
                    ret: primitive.none,
                    vars: VarMap::new(),
@ -882,6 +1009,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,14 +1,30 @@
-use inkwell::{
+use std::{
-    types::{BasicType, BasicTypeEnum},
+    collections::{HashMap, HashSet},
-    values::BasicValueEnum,
+    sync::{
-    AddressSpace,
+        atomic::{AtomicBool, Ordering::Relaxed},
        Arc,
    },
 };
 use itertools::Itertools;
 use parking_lot::RwLock;
 use pyo3::{
    types::{PyDict, PyTuple},
    PyAny, PyObject, PyResult, Python,
 };
 use nac3core::{
    codegen::{
        classes::{NDArrayType, ProxyType},
        CodeGenContext, CodeGenerator,
    },
    inkwell::{
        module::Linkage,
        types::{BasicType, BasicTypeEnum},
        values::BasicValueEnum,
        AddressSpace,
    },
    nac3parser::ast::{self, StrRef},
    symbol_resolver::{StaticValue, SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{
        helper::PrimDef,
@ -20,21 +36,8 @@ use nac3core::{
        typedef::{into_var_map, iter_type_vars, Type, TypeEnum, TypeVar, Unifier, VarMap},
    },
 };
 use nac3parser::ast::{self, StrRef};
 use parking_lot::{Mutex, RwLock};
 use pyo3::{
    types::{PyDict, PyTuple},
    PyAny, PyObject, PyResult, Python,
 };
 use std::{
    collections::{HashMap, HashSet},
    sync::{
        atomic::{AtomicBool, Ordering::Relaxed},
        Arc,
    },
 };
-use crate::PrimitivePythonId;
+use super::PrimitivePythonId;
 pub enum PrimitiveValue {
    I32(i32),
@ -79,7 +82,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 +135,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 +167,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()) {
@ -351,7 +355,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 {
@ -555,7 +559,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 = {
@ -797,7 +804,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
@ -972,7 +981,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));
@ -991,8 +1000,15 @@ impl InnerResolver {
                }
                _ => 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);
@ -1196,7 +1212,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()?;
@ -1452,6 +1470,7 @@ impl SymbolResolver for Resolver {
        &self,
        id: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        let sym_value = {
            let id_to_val = self.0.id_to_pyval.read();
--- a/nac3artiq/src/timeline.rs
+++ b/nac3artiq/src/timeline.rs
@ -1,9 +1,12 @@
-use inkwell::{
+use itertools::Either;
 use nac3core::{
    codegen::CodeGenContext,
    inkwell::{
        values::{BasicValueEnum, CallSiteValue},
        AddressSpace, AtomicOrdering,
    },
 };
 use itertools::Either;
 use nac3core::codegen::CodeGenContext;
 /// Functions for manipulating the timeline.
 pub trait TimeFns {
@ -31,7 +34,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 +83,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 +112,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 +210,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 +261,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,6 @@ constant-optimization = ["fold"]
 fold = []
 [dependencies]
 lazy_static = "1.5"
 parking_lot = "0.12"
 string-interner = "0.17"
 fxhash = "0.2"
--- a/nac3ast/src/ast_gen.rs
+++ b/nac3ast/src/ast_gen.rs
@ -5,14 +5,12 @@ pub use crate::location::Location;
 use fxhash::FxBuildHasher;
 use parking_lot::{Mutex, MutexGuard};
-use std::{cell::RefCell, collections::HashMap, fmt};
+use std::{cell::RefCell, collections::HashMap, fmt, sync::LazyLock};
 use string_interner::{symbol::SymbolU32, DefaultBackend, StringInterner};
 pub type Interner = StringInterner<DefaultBackend, FxBuildHasher>;
-lazy_static! {
+static INTERNER: LazyLock<Mutex<Interner>> =
-    static ref INTERNER: Mutex<Interner> =
+    LazyLock::new(|| Mutex::new(StringInterner::with_hasher(FxBuildHasher::default())));
        Mutex::new(StringInterner::with_hasher(FxBuildHasher::default()));
 }
 thread_local! {
    static LOCAL_INTERNER: RefCell<HashMap<String, StrRef>> = RefCell::default();
--- a/nac3ast/src/lib.rs
+++ b/nac3ast/src/lib.rs
@ -14,9 +14,6 @@
    clippy::wildcard_imports
 )]
 #[macro_use]
 extern crate lazy_static;
 mod ast_gen;
 mod constant;
 #[cfg(feature = "fold")]
--- a/nac3core/Cargo.toml
+++ b/nac3core/Cargo.toml
@ -4,20 +4,23 @@ version = "0.1.0"
 authors = ["M-Labs"]
 edition = "2021"
 [features]
 no-escape-analysis = []
 [dependencies]
 itertools = "0.13"
 crossbeam = "0.8"
-indexmap = "2.2"
+indexmap = "2.6"
 parking_lot = "0.12"
-rayon = "1.8"
+rayon = "1.10"
 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
@ -1,4 +1,3 @@
 use regex::Regex;
 use std::{
    env,
    fs::File,
@ -7,38 +6,53 @@ use std::{
    process::{Command, Stdio},
 };
 use regex::Regex;
 fn main() {
-    const FILE: &str = "src/codegen/irrt/irrt.cpp";
+    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",
        "-fno-exceptions",
        "-fno-rtti",
        match env::var("PROFILE").as_deref() {
            Ok("debug") => "-O0",
            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()
@ -52,7 +66,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]);
@ -63,18 +87,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,102 @@
-use inkwell::types::BasicTypeEnum;
+use inkwell::{
-use inkwell::values::BasicValueEnum;
+    types::BasicTypeEnum,
-use inkwell::{FloatPredicate, IntPredicate, OptimizationLevel};
+    values::{BasicValue, BasicValueEnum, IntValue, PointerValue},
    FloatPredicate, IntPredicate, OptimizationLevel,
 };
 use itertools::Itertools;
-use crate::codegen::classes::{NDArrayValue, ProxyValue, UntypedArrayLikeAccessor};
+use super::{
-use crate::codegen::numpy::ndarray_elementwise_unaryop_impl;
+    classes::{
-use crate::codegen::stmt::gen_for_callback_incrementing;
+        ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor,
-use crate::codegen::{extern_fns, irrt, llvm_intrinsics, numpy, CodeGenContext, CodeGenerator};
+        UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
-use crate::toplevel::helper::PrimDef;
+    },
-use crate::toplevel::numpy::unpack_ndarray_var_tys;
+    expr::destructure_range,
-use crate::typecheck::typedef::Type;
+    extern_fns, irrt,
    irrt::calculate_len_for_slice_range,
    llvm_intrinsics,
    macros::codegen_unreachable,
    numpy,
    numpy::ndarray_elementwise_unaryop_impl,
    stmt::gen_for_callback_incrementing,
    CodeGenContext, CodeGenerator,
 };
 use crate::{
    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys},
    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 +107,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));
@ -602,7 +677,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 +736,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 +794,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 +868,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 +895,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 +919,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 +1056,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 };
@ -1459,7 +1496,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 +1563,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 +1630,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 +1697,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 +1820,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 +1887,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 +1911,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
@ -1,17 +1,16 @@
-use crate::codegen::{
+use inkwell::{
    context::Context,
    types::{AnyTypeEnum, ArrayType, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
    values::{ArrayValue, BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
    AddressSpace, IntPredicate,
 };
 use super::{
    irrt::{call_ndarray_calc_size, call_ndarray_flatten_index},
    llvm_intrinsics::call_int_umin,
    stmt::gen_for_callback_incrementing,
    CodeGenContext, CodeGenerator,
 };
 use inkwell::context::Context;
 use inkwell::types::{ArrayType, BasicType, StructType};
 use inkwell::values::{ArrayValue, BasicValue, StructValue};
 use inkwell::{
    types::{AnyTypeEnum, BasicTypeEnum, IntType, PointerType},
    values::{BasicValueEnum, IntValue, PointerValue},
    AddressSpace, IntPredicate,
 };
 /// A LLVM type that is used to represent a non-primitive type in NAC3.
 pub trait ProxyType<'ctx>: Into<Self::Base> {
@ -1250,11 +1249,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()
    }
 }
@ -1404,7 +1405,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();
@ -1717,6 +1718,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
@ -1,3 +1,9 @@
 use std::collections::HashMap;
 use indexmap::IndexMap;
 use nac3parser::ast::StrRef;
 use crate::{
    symbol_resolver::SymbolValue,
    toplevel::DefinitionId,
@ -9,10 +15,6 @@ use crate::{
    },
 };
 use indexmap::IndexMap;
 use nac3parser::ast::StrRef;
 use std::collections::HashMap;
 pub struct ConcreteTypeStore {
    store: Vec<ConcreteTypeEnum>,
 }
@ -25,6 +27,7 @@ pub struct ConcreteFuncArg {
    pub name: StrRef,
    pub ty: ConcreteType,
    pub default_value: Option<SymbolValue>,
    pub is_vararg: bool,
 }
 #[derive(Clone, Debug)]
@ -46,6 +49,7 @@ pub enum ConcreteTypeEnum {
    TPrimitive(Primitive),
    TTuple {
        ty: Vec<ConcreteType>,
        is_vararg_ctx: bool,
    },
    TObj {
        obj_id: DefinitionId,
@ -102,8 +106,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),
@ -158,11 +170,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::TObj { obj_id, fields, params } => ConcreteTypeEnum::TObj {
                    obj_id: *obj_id,
@ -248,11 +261,12 @@ 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::TVirtual { ty } => {
                TypeEnum::TVirtual { ty: self.to_unifier_type(unifier, primitives, *ty, cache) }
@ -277,6 +291,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
@ -1,8 +1,10 @@
-use inkwell::attributes::{Attribute, AttributeLoc};
+use inkwell::{
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue};
+    attributes::{Attribute, AttributeLoc},
    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
 };
 use itertools::Either;
-use crate::codegen::CodeGenContext;
+use super::CodeGenContext;
 /// Macro to generate extern function
 /// Both function return type and function parameter type are `FloatValue`
@ -13,8 +15,8 @@ use crate::codegen::CodeGenContext;
 /// * `$extern_fn:literal`: Name of underlying extern function
 ///
 /// Optional Arguments:
-/// * `$(,$attributes:literal)*)`: Attributes linked with the extern function
+/// * `$(,$attributes:literal)*)`: Attributes linked with the extern function.
-/// The default attributes are "mustprogress", "nofree", "nounwind", "willreturn", and "writeonly"
+///   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`
@ -130,3 +132,62 @@ pub fn call_ldexp<'ctx>(
        .map(Either::unwrap_left)
        .unwrap()
 }
 /// Macro to generate `np_linalg` and `sp_linalg` functions
 /// The function takes as input `NDArray` and returns ()
 ///
 /// Arguments:
 /// * `$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>,
        ){
            const FN_NAME: &str = $extern_fn;
            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
                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(attr), 0),
                    );
                }
                func
            });
            ctx.builder.build_call(extern_fn, &[$($input_matrix.into(),)*], name.unwrap_or_default()).unwrap();
        }
    };
 }
 generate_linalg_extern_fn!(call_np_linalg_cholesky, "np_linalg_cholesky", 2);
 generate_linalg_extern_fn!(call_np_linalg_qr, "np_linalg_qr", 3);
 generate_linalg_extern_fn!(call_np_linalg_svd, "np_linalg_svd", 4);
 generate_linalg_extern_fn!(call_np_linalg_inv, "np_linalg_inv", 2);
 generate_linalg_extern_fn!(call_np_linalg_pinv, "np_linalg_pinv", 2);
 generate_linalg_extern_fn!(call_np_linalg_matrix_power, "np_linalg_matrix_power", 3);
 generate_linalg_extern_fn!(call_np_linalg_det, "np_linalg_det", 2);
 generate_linalg_extern_fn!(call_sp_linalg_lu, "sp_linalg_lu", 3);
 generate_linalg_extern_fn!(call_sp_linalg_schur, "sp_linalg_schur", 3);
 generate_linalg_extern_fn!(call_sp_linalg_hessenberg, "sp_linalg_hessenberg", 3);
--- a/nac3core/src/codegen/generator.rs
+++ b/nac3core/src/codegen/generator.rs
@ -1,16 +1,18 @@
 use crate::{
    codegen::{bool_to_i1, bool_to_i8, classes::ArraySliceValue, expr::*, stmt::*, CodeGenContext},
    symbol_resolver::ValueEnum,
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::typedef::{FunSignature, Type},
 };
 use inkwell::{
    context::Context,
    types::{BasicTypeEnum, IntType},
    values::{BasicValueEnum, IntValue, PointerValue},
 };
 use nac3parser::ast::{Expr, Stmt, StrRef};
 use super::{bool_to_i1, bool_to_i8, classes::ArraySliceValue, expr::*, stmt::*, CodeGenContext};
 use crate::{
    symbol_resolver::ValueEnum,
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::typedef::{FunSignature, Type},
 };
 pub trait CodeGenerator {
    /// Return the module name for the code generator.
    fn get_name(&self) -> &str;
@ -57,6 +59,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 +126,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.cpp
+++ b/nac3core/src/codegen/irrt/irrt.cpp
@ -1,414 +0,0 @@
 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);
 // 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;
 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;
 }
 // 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;
 }
 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" {
 #define DEF_nac3_int_exp_(T) \
    T __nac3_int_exp_##T(T base, T exp) {\
        return __nac3_int_exp_impl(base, exp);\
    }
 DEF_nac3_int_exp_(int32_t)
 DEF_nac3_int_exp_(int64_t)
 DEF_nac3_int_exp_(uint32_t)
 DEF_nac3_int_exp_(uint64_t)
 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;
    }
 }
 // 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;
 }
 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 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);
 }
 }  // extern "C"
--- a/nac3core/src/codegen/irrt/mod.rs
+++ b/nac3core/src/codegen/irrt/mod.rs
@ -1,28 +1,30 @@
 use crate::typecheck::typedef::Type;
 use super::{
    classes::{
        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
        TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
    },
    llvm_intrinsics, 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;
 use super::{
    classes::{
        ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ListValue, NDArrayValue,
        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
    },
    llvm_intrinsics,
    macros::codegen_unreachable,
    stmt::gen_for_callback_incrementing,
    CodeGenContext, CodeGenerator,
 };
 use crate::{symbol_resolver::SymbolResolver, typecheck::typedef::Type};
 #[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 +40,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 +76,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 +462,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 +589,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, '_>,
@ -585,7 +607,7 @@ where
    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_pusize.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
@ -636,7 +658,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(|| {
@ -705,7 +727,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(|| {
@ -773,7 +795,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(|| {
@ -798,6 +820,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| {
@ -892,7 +915,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
@ -1,12 +1,14 @@
-use crate::codegen::CodeGenContext;
+use inkwell::{
-use inkwell::context::Context;
+    context::Context,
-use inkwell::intrinsics::Intrinsic;
+    intrinsics::Intrinsic,
-use inkwell::types::AnyTypeEnum::IntType;
+    types::{AnyTypeEnum::IntType, FloatType},
-use inkwell::types::FloatType;
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue},
-use inkwell::values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue};
+    AddressSpace,
-use inkwell::AddressSpace;
+};
 use itertools::Either;
 use super::CodeGenContext;
 /// Returns the string representation for the floating-point type `ft` when used in intrinsic
 /// functions.
 fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
@ -35,6 +37,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>(
@ -149,7 +185,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()
    };
@ -157,7 +193,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()
    };
@ -171,8 +207,9 @@ pub fn call_memcpy_generic<'ctx>(
 /// * `$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)
+/// * `$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
+///   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 {
@ -188,7 +225,7 @@ macro_rules! 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
+/// * `$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
--- a/nac3core/src/codegen/mod.rs
+++ b/nac3core/src/codegen/mod.rs
@ -1,12 +1,12 @@
-use crate::{
+use std::{
-    codegen::classes::{ListType, NDArrayType, ProxyType, RangeType},
+    collections::{HashMap, HashSet},
-    symbol_resolver::{StaticValue, SymbolResolver},
+    sync::{
-    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
+        atomic::{AtomicBool, Ordering},
-    typecheck::{
+        Arc,
        type_inferencer::{CodeLocation, PrimitiveStore},
        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
    },
    thread,
 };
 use crossbeam::channel::{unbounded, Receiver, Sender};
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -24,14 +24,21 @@ use inkwell::{
    AddressSpace, IntPredicate, OptimizationLevel,
 };
 use itertools::Itertools;
 use nac3parser::ast::{Location, Stmt, StrRef};
 use parking_lot::{Condvar, Mutex};
-use std::collections::{HashMap, HashSet};
+
-use std::sync::{
+use nac3parser::ast::{Location, Stmt, StrRef};
-    atomic::{AtomicBool, Ordering},
+
-    Arc,
+use crate::{
    symbol_resolver::{StaticValue, SymbolResolver},
    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, TopLevelContext, TopLevelDef},
    typecheck::{
        type_inferencer::{CodeLocation, PrimitiveStore},
        typedef::{CallId, FuncArg, Type, TypeEnum, Unifier},
    },
 };
-use std::thread;
+use classes::{ListType, NDArrayType, ProxyType, RangeType};
 use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
 pub use generator::{CodeGenerator, DefaultCodeGenerator};
 pub mod builtin_fns;
 pub mod classes;
@ -47,8 +54,21 @@ pub mod stmt;
 #[cfg(test)]
 mod test;
-use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
+mod macros {
-pub use generator::{CodeGenerator, DefaultCodeGenerator};
+    /// 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 {
@ -68,6 +88,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 +368,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 +395,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 +464,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>>,
@ -520,8 +558,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| {
@ -551,7 +591,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>>,
@ -560,11 +600,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`.
@ -589,6 +629,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,
@ -700,6 +774,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),
@ -722,7 +797,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,
@ -741,9 +819,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;
@ -771,9 +852,10 @@ pub fn gen_func_impl<
    builder.position_at_end(init_bb);
    let body_bb = context.append_basic_block(fn_val, "body");
    // Store non-vararg argument values into local variables
    let mut var_assignment = HashMap::new();
    let offset = u32::from(has_sret);
-    for (n, arg) in args.iter().enumerate() {
+    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,
@ -806,6 +888,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 {
@ -1028,3 +1112,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
@ -1,5 +1,12 @@
-use crate::{
+use inkwell::{
-    codegen::{
+    types::{AnyTypeEnum, BasicType, BasicTypeEnum, PointerType},
    values::{BasicValue, BasicValueEnum, IntValue, PointerValue},
    AddressSpace, IntPredicate, OptimizationLevel,
 };
 use nac3parser::ast::{Operator, StrRef};
 use super::{
    classes::{
        ArrayLikeIndexer, ArrayLikeValue, ListType, ListValue, NDArrayType, NDArrayValue,
        ProxyType, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
@ -8,13 +15,14 @@ use crate::{
    expr::gen_binop_expr_with_values,
    irrt::{
        calculate_len_for_slice_range, call_ndarray_calc_broadcast,
-            call_ndarray_calc_broadcast_index, call_ndarray_calc_nd_indices,
+        call_ndarray_calc_broadcast_index, call_ndarray_calc_nd_indices, call_ndarray_calc_size,
            call_ndarray_calc_size,
    },
    llvm_intrinsics::{self, call_memcpy_generic},
    macros::codegen_unreachable,
    stmt::{gen_for_callback_incrementing, gen_for_range_callback, gen_if_else_expr_callback},
    CodeGenContext, CodeGenerator,
-    },
+};
 use crate::{
    symbol_resolver::ValueEnum,
    toplevel::{
        helper::PrimDef,
@ -26,13 +34,6 @@ use crate::{
        typedef::{FunSignature, Type, TypeEnum},
    },
 };
 use inkwell::types::{AnyTypeEnum, BasicTypeEnum, PointerType};
 use inkwell::{
    types::BasicType,
    values::{BasicValueEnum, IntValue, PointerValue},
    AddressSpace, IntPredicate, OptimizationLevel,
 };
 use nac3parser::ast::{Operator, StrRef};
 /// Creates an uninitialized `NDArray` instance.
 fn create_ndarray_uninitialized<'ctx, G: CodeGenerator + ?Sized>(
@ -86,6 +87,7 @@ where
    gen_for_callback_incrementing(
        generator,
        ctx,
        None,
        llvm_usize.const_zero(),
        (shape_len, false),
        |generator, ctx, _, i| {
@ -131,6 +133,7 @@ where
    gen_for_callback_incrementing(
        generator,
        ctx,
        None,
        llvm_usize.const_zero(),
        (shape_len, false),
        |generator, ctx, _, i| {
@ -157,7 +160,7 @@ where
 ///
 /// * `elem_ty` - The element type of the `NDArray`.
 /// * `shape` - The shape of the `NDArray`, represented am array of [`IntValue`]s.
-fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>(
+pub fn create_ndarray_const_shape<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    elem_ty: Type,
@ -252,9 +255,9 @@ fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
    } else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
        ctx.ctx.bool_type().const_zero().into()
    } else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
-        ctx.gen_string(generator, "")
+        ctx.gen_string(generator, "").into()
    } else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    }
 }
@ -280,9 +283,9 @@ fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
    } else if ctx.unifier.unioned(elem_ty, ctx.primitives.bool) {
        ctx.ctx.bool_type().const_int(1, false).into()
    } else if ctx.unifier.unioned(elem_ty, ctx.primitives.str) {
-        ctx.gen_string(generator, "1")
+        ctx.gen_string(generator, "1").into()
    } else {
-        unreachable!()
+        codegen_unreachable!(ctx)
    }
 }
@ -350,7 +353,7 @@ fn call_ndarray_empty_impl<'ctx, G: CodeGenerator + ?Sized>(
            create_ndarray_const_shape(generator, ctx, elem_ty, &[shape_int])
        }
-        _ => unreachable!(),
+        _ => codegen_unreachable!(ctx),
    }
 }
@ -382,6 +385,7 @@ where
    gen_for_callback_incrementing(
        generator,
        ctx,
        None,
        llvm_usize.const_zero(),
        (ndarray_num_elems, false),
        |generator, ctx, _, i| {
@ -620,7 +624,7 @@ fn call_ndarray_full_impl<'ctx, G: CodeGenerator + ?Sized>(
        } else if fill_value.is_int_value() || fill_value.is_float_value() {
            fill_value
        } else {
-            unreachable!()
+            codegen_unreachable!(ctx)
        };
        Ok(value)
@ -703,11 +707,12 @@ fn ndarray_from_ndlist_impl<'ctx, G: CodeGenerator + ?Sized>(
            gen_for_range_callback(
                generator,
                ctx,
                None,
                true,
                |_, _| Ok(llvm_usize.const_zero()),
                (|_, ctx| Ok(src_lst.load_size(ctx, None)), false),
                |_, _| Ok(llvm_usize.const_int(1, false)),
-                |generator, ctx, i| {
+                |generator, ctx, _, i| {
                    let offset = ctx.builder.build_int_mul(stride, i, "").unwrap();
                    let dst_ptr =
@ -934,7 +939,7 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                        .build_store(
                            lst,
                            ctx.builder
-                                .build_bitcast(object.as_base_value(), llvm_plist_i8, "")
+                                .build_bit_cast(object.as_base_value(), llvm_plist_i8, "")
                                .unwrap(),
                        )
                        .unwrap();
@ -943,11 +948,12 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                    gen_for_range_callback(
                        generator,
                        ctx,
                        None,
                        true,
                        |_, _| Ok(llvm_usize.const_zero()),
                        (|_, _| Ok(stop), false),
                        |_, _| Ok(llvm_usize.const_int(1, false)),
-                        |generator, ctx, _| {
+                        |generator, ctx, _, _| {
                            let plist_plist_i8 = make_llvm_list(llvm_plist_i8.into())
                                .ptr_type(AddressSpace::default());
@ -955,7 +961,7 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                                .builder
                                .build_load(lst, "")
                                .map(BasicValueEnum::into_pointer_value)
-                                .map(|v| ctx.builder.build_bitcast(v, plist_plist_i8, "").unwrap())
+                                .map(|v| ctx.builder.build_bit_cast(v, plist_plist_i8, "").unwrap())
                                .map(BasicValueEnum::into_pointer_value)
                                .unwrap();
                            let this_dim = ListValue::from_ptr_val(this_dim, llvm_usize, None);
@ -974,7 +980,9 @@ fn call_ndarray_array_impl<'ctx, G: CodeGenerator + ?Sized>(
                            ctx.builder
                                .build_store(
                                    lst,
-                                    ctx.builder.build_bitcast(next_dim, llvm_plist_i8, "").unwrap(),
+                                    ctx.builder
                                        .build_bit_cast(next_dim, llvm_plist_i8, "")
                                        .unwrap(),
                                )
                                .unwrap();
@ -1086,13 +1094,17 @@ fn ndarray_sliced_copyto_impl<'ctx, G: CodeGenerator + ?Sized>(
    // If there are no (remaining) slice expressions, memcpy the entire dimension
    if slices.is_empty() {
        let sizeof_elem = ctx.get_llvm_type(generator, elem_ty).size_of().unwrap();
        let stride = call_ndarray_calc_size(
            generator,
            ctx,
            &src_arr.dim_sizes(),
            (Some(llvm_usize.const_int(dim, false)), None),
        );
-        let sizeof_elem = ctx.get_llvm_type(generator, elem_ty).size_of().unwrap();
+        let stride =
            ctx.builder.build_int_z_extend_or_bit_cast(stride, sizeof_elem.get_type(), "").unwrap();
        let cpy_len = ctx.builder.build_int_mul(stride, sizeof_elem, "").unwrap();
        call_memcpy_generic(ctx, dst_slice_ptr, src_slice_ptr, cpy_len, llvm_i1.const_zero());
@ -1126,11 +1138,12 @@ fn ndarray_sliced_copyto_impl<'ctx, G: CodeGenerator + ?Sized>(
    gen_for_range_callback(
        generator,
        ctx,
        None,
        false,
        |_, _| Ok(start),
        (|_, _| Ok(stop), true),
        |_, _| Ok(step),
-        |generator, ctx, src_i| {
+        |generator, ctx, _, src_i| {
            // Calculate the offset of the active slice
            let src_data_offset = ctx.builder.build_int_mul(src_stride, src_i, "").unwrap();
            let dst_i =
@ -1243,6 +1256,7 @@ pub fn ndarray_sliced_copy<'ctx, G: CodeGenerator + ?Sized>(
        gen_for_callback_incrementing(
            generator,
            ctx,
            None,
            llvm_usize.const_int(slices.len() as u64, false),
            (this.load_ndims(ctx), false),
            |generator, ctx, _, idx| {
@ -1647,6 +1661,7 @@ pub fn ndarray_matmul_2d<'ctx, G: CodeGenerator>(
        gen_for_callback_incrementing(
            generator,
            ctx,
            None,
            llvm_i32.const_zero(),
            (common_dim, false),
            |generator, ctx, _, i| {
@ -2005,7 +2020,7 @@ pub fn gen_ndarray_fill<'ctx>(
            } else if value_arg.is_int_value() || value_arg.is_float_value() {
                value_arg
            } else {
-                unreachable!()
+                codegen_unreachable!(ctx)
            };
            Ok(value)
@ -2014,3 +2029,497 @@ pub fn gen_ndarray_fill<'ctx>(
    Ok(())
 }
 /// Generates LLVM IR for `ndarray.transpose`.
 pub fn ndarray_transpose<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "ndarray_transpose";
    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 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let n_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None));
        // Dimensions are reversed in the transposed array
        let out = create_ndarray_dyn_shape(
            generator,
            ctx,
            elem_ty,
            &n1,
            |_, ctx, n| Ok(n.load_ndims(ctx)),
            |generator, ctx, n, idx| {
                let new_idx = ctx.builder.build_int_sub(n.load_ndims(ctx), idx, "").unwrap();
                let new_idx = ctx
                    .builder
                    .build_int_sub(new_idx, new_idx.get_type().const_int(1, false), "")
                    .unwrap();
                unsafe { Ok(n.dim_sizes().get_typed_unchecked(ctx, generator, &new_idx, None)) }
            },
        )
        .unwrap();
        gen_for_callback_incrementing(
            generator,
            ctx,
            None,
            llvm_usize.const_zero(),
            (n_sz, false),
            |generator, ctx, _, idx| {
                let elem = unsafe { n1.data().get_unchecked(ctx, generator, &idx, None) };
                let new_idx = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
                let rem_idx = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
                ctx.builder.build_store(new_idx, llvm_usize.const_zero()).unwrap();
                ctx.builder.build_store(rem_idx, idx).unwrap();
                // Incrementally calculate the new index in the transposed array
                // For each index, we first decompose it into the n-dims and use those to reconstruct the new index
                // The formula used for indexing is:
                // idx = dim_n * ( ... (dim2 * (dim0 * dim1) + dim1) + dim2 ... ) + dim_n
                gen_for_callback_incrementing(
                    generator,
                    ctx,
                    None,
                    llvm_usize.const_zero(),
                    (n1.load_ndims(ctx), false),
                    |generator, ctx, _, ndim| {
                        let ndim_rev =
                            ctx.builder.build_int_sub(n1.load_ndims(ctx), ndim, "").unwrap();
                        let ndim_rev = ctx
                            .builder
                            .build_int_sub(ndim_rev, llvm_usize.const_int(1, false), "")
                            .unwrap();
                        let dim = unsafe {
                            n1.dim_sizes().get_typed_unchecked(ctx, generator, &ndim_rev, None)
                        };
                        let rem_idx_val =
                            ctx.builder.build_load(rem_idx, "").unwrap().into_int_value();
                        let new_idx_val =
                            ctx.builder.build_load(new_idx, "").unwrap().into_int_value();
                        let add_component =
                            ctx.builder.build_int_unsigned_rem(rem_idx_val, dim, "").unwrap();
                        let rem_idx_val =
                            ctx.builder.build_int_unsigned_div(rem_idx_val, dim, "").unwrap();
                        let new_idx_val = ctx.builder.build_int_mul(new_idx_val, dim, "").unwrap();
                        let new_idx_val =
                            ctx.builder.build_int_add(new_idx_val, add_component, "").unwrap();
                        ctx.builder.build_store(rem_idx, rem_idx_val).unwrap();
                        ctx.builder.build_store(new_idx, new_idx_val).unwrap();
                        Ok(())
                    },
                    llvm_usize.const_int(1, false),
                )?;
                let new_idx_val = ctx.builder.build_load(new_idx, "").unwrap().into_int_value();
                unsafe { out.data().set_unchecked(ctx, generator, &new_idx_val, elem) };
                Ok(())
            },
            llvm_usize.const_int(1, false),
        )?;
        Ok(out.as_base_value().into())
    } else {
        codegen_unreachable!(
            ctx,
            "{FN_NAME}() not supported for '{}'",
            format!("'{}'", ctx.unifier.stringify(x1_ty))
        )
    }
 }
 /// LLVM-typed implementation for generating the implementation for `ndarray.reshape`.
 ///
 /// * `x1` - `NDArray` to reshape.
 /// * `shape` - The `shape` parameter used to construct the new `NDArray`.
 ///   Just like numpy, the `shape` argument can be:
 ///   1. A list of `int32`;   e.g., `np.reshape(arr, [600, -1, 3])`
 ///   2. A tuple of `int32`;  e.g., `np.reshape(arr, (-1, 800, 3))`
 ///   3. A scalar `int32`;     e.g., `np.reshape(arr, 3)`
 ///
 /// Note that unlike other generating functions, one of the dimensions in the shape can be negative.
 pub fn ndarray_reshape<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
    x1: (Type, BasicValueEnum<'ctx>),
    shape: (Type, BasicValueEnum<'ctx>),
 ) -> Result<BasicValueEnum<'ctx>, String> {
    const FN_NAME: &str = "ndarray_reshape";
    let (x1_ty, x1) = x1;
    let (_, shape) = shape;
    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 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
        let n_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None));
        let acc = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
        let num_neg = generator.gen_var_alloc(ctx, llvm_usize.into(), None)?;
        ctx.builder.build_store(acc, llvm_usize.const_int(1, false)).unwrap();
        ctx.builder.build_store(num_neg, llvm_usize.const_zero()).unwrap();
        let out = match shape {
            BasicValueEnum::PointerValue(shape_list_ptr)
                if ListValue::is_instance(shape_list_ptr, llvm_usize).is_ok() =>
            {
                // 1. A list of ints; e.g., `np.reshape(arr, [int64(600), int64(800, -1])`
                let shape_list = ListValue::from_ptr_val(shape_list_ptr, llvm_usize, None);
                // Check for -1 in dimensions
                gen_for_callback_incrementing(
                    generator,
                    ctx,
                    None,
                    llvm_usize.const_zero(),
                    (shape_list.load_size(ctx, None), false),
                    |generator, ctx, _, idx| {
                        let ele =
                            shape_list.data().get(ctx, generator, &idx, None).into_int_value();
                        let ele = ctx.builder.build_int_s_extend(ele, llvm_usize, "").unwrap();
                        gen_if_else_expr_callback(
                            generator,
                            ctx,
                            |_, ctx| {
                                Ok(ctx
                                    .builder
                                    .build_int_compare(
                                        IntPredicate::SLT,
                                        ele,
                                        llvm_usize.const_zero(),
                                        "",
                                    )
                                    .unwrap())
                            },
                            |_, ctx| -> Result<Option<IntValue>, String> {
                                let num_neg_value =
                                    ctx.builder.build_load(num_neg, "").unwrap().into_int_value();
                                let num_neg_value = ctx
                                    .builder
                                    .build_int_add(
                                        num_neg_value,
                                        llvm_usize.const_int(1, false),
                                        "",
                                    )
                                    .unwrap();
                                ctx.builder.build_store(num_neg, num_neg_value).unwrap();
                                Ok(None)
                            },
                            |_, ctx| {
                                let acc_value =
                                    ctx.builder.build_load(acc, "").unwrap().into_int_value();
                                let acc_value =
                                    ctx.builder.build_int_mul(acc_value, ele, "").unwrap();
                                ctx.builder.build_store(acc, acc_value).unwrap();
                                Ok(None)
                            },
                        )?;
                        Ok(())
                    },
                    llvm_usize.const_int(1, false),
                )?;
                let acc_val = ctx.builder.build_load(acc, "").unwrap().into_int_value();
                let rem = ctx.builder.build_int_unsigned_div(n_sz, acc_val, "").unwrap();
                // Generate the output shape by filling -1 with `rem`
                create_ndarray_dyn_shape(
                    generator,
                    ctx,
                    elem_ty,
                    &shape_list,
                    |_, ctx, _| Ok(shape_list.load_size(ctx, None)),
                    |generator, ctx, shape_list, idx| {
                        let dim =
                            shape_list.data().get(ctx, generator, &idx, None).into_int_value();
                        let dim = ctx.builder.build_int_s_extend(dim, llvm_usize, "").unwrap();
                        Ok(gen_if_else_expr_callback(
                            generator,
                            ctx,
                            |_, ctx| {
                                Ok(ctx
                                    .builder
                                    .build_int_compare(
                                        IntPredicate::SLT,
                                        dim,
                                        llvm_usize.const_zero(),
                                        "",
                                    )
                                    .unwrap())
                            },
                            |_, _| Ok(Some(rem)),
                            |_, _| Ok(Some(dim)),
                        )?
                        .unwrap()
                        .into_int_value())
                    },
                )
            }
            BasicValueEnum::StructValue(shape_tuple) => {
                // 2. A tuple of `int32`;  e.g., `np.reshape(arr, (-1, 800, 3))`
                let ndims = shape_tuple.get_type().count_fields();
                // Check for -1 in dims
                for dim_i in 0..ndims {
                    let dim = ctx
                        .builder
                        .build_extract_value(shape_tuple, dim_i, "")
                        .unwrap()
                        .into_int_value();
                    let dim = ctx.builder.build_int_s_extend(dim, llvm_usize, "").unwrap();
                    gen_if_else_expr_callback(
                        generator,
                        ctx,
                        |_, ctx| {
                            Ok(ctx
                                .builder
                                .build_int_compare(
                                    IntPredicate::SLT,
                                    dim,
                                    llvm_usize.const_zero(),
                                    "",
                                )
                                .unwrap())
                        },
                        |_, ctx| -> Result<Option<IntValue>, String> {
                            let num_negs =
                                ctx.builder.build_load(num_neg, "").unwrap().into_int_value();
                            let num_negs = ctx
                                .builder
                                .build_int_add(num_negs, llvm_usize.const_int(1, false), "")
                                .unwrap();
                            ctx.builder.build_store(num_neg, num_negs).unwrap();
                            Ok(None)
                        },
                        |_, ctx| {
                            let acc_val = ctx.builder.build_load(acc, "").unwrap().into_int_value();
                            let acc_val = ctx.builder.build_int_mul(acc_val, dim, "").unwrap();
                            ctx.builder.build_store(acc, acc_val).unwrap();
                            Ok(None)
                        },
                    )?;
                }
                let acc_val = ctx.builder.build_load(acc, "").unwrap().into_int_value();
                let rem = ctx.builder.build_int_unsigned_div(n_sz, acc_val, "").unwrap();
                let mut shape = Vec::with_capacity(ndims as usize);
                // Reconstruct shape filling negatives with rem
                for dim_i in 0..ndims {
                    let dim = ctx
                        .builder
                        .build_extract_value(shape_tuple, dim_i, "")
                        .unwrap()
                        .into_int_value();
                    let dim = ctx.builder.build_int_s_extend(dim, llvm_usize, "").unwrap();
                    let dim = gen_if_else_expr_callback(
                        generator,
                        ctx,
                        |_, ctx| {
                            Ok(ctx
                                .builder
                                .build_int_compare(
                                    IntPredicate::SLT,
                                    dim,
                                    llvm_usize.const_zero(),
                                    "",
                                )
                                .unwrap())
                        },
                        |_, _| Ok(Some(rem)),
                        |_, _| Ok(Some(dim)),
                    )?
                    .unwrap()
                    .into_int_value();
                    shape.push(dim);
                }
                create_ndarray_const_shape(generator, ctx, elem_ty, shape.as_slice())
            }
            BasicValueEnum::IntValue(shape_int) => {
                // 3. A scalar `int32`;     e.g., `np.reshape(arr, 3)`
                let shape_int = gen_if_else_expr_callback(
                    generator,
                    ctx,
                    |_, ctx| {
                        Ok(ctx
                            .builder
                            .build_int_compare(
                                IntPredicate::SLT,
                                shape_int,
                                llvm_usize.const_zero(),
                                "",
                            )
                            .unwrap())
                    },
                    |_, _| Ok(Some(n_sz)),
                    |_, ctx| {
                        Ok(Some(ctx.builder.build_int_s_extend(shape_int, llvm_usize, "").unwrap()))
                    },
                )?
                .unwrap()
                .into_int_value();
                create_ndarray_const_shape(generator, ctx, elem_ty, &[shape_int])
            }
            _ => codegen_unreachable!(ctx),
        }
        .unwrap();
        // Only allow one dimension to be negative
        let num_negs = ctx.builder.build_load(num_neg, "").unwrap().into_int_value();
        ctx.make_assert(
            generator,
            ctx.builder
                .build_int_compare(IntPredicate::ULT, num_negs, llvm_usize.const_int(2, false), "")
                .unwrap(),
            "0:ValueError",
            "can only specify one unknown dimension",
            [None, None, None],
            ctx.current_loc,
        );
        // The new shape must be compatible with the old shape
        let out_sz = call_ndarray_calc_size(generator, ctx, &out.dim_sizes(), (None, None));
        ctx.make_assert(
            generator,
            ctx.builder.build_int_compare(IntPredicate::EQ, out_sz, n_sz, "").unwrap(),
            "0:ValueError",
            "cannot reshape array of size {0} into provided shape of size {1}",
            [Some(n_sz), Some(out_sz), None],
            ctx.current_loc,
        );
        gen_for_callback_incrementing(
            generator,
            ctx,
            None,
            llvm_usize.const_zero(),
            (n_sz, false),
            |generator, ctx, _, idx| {
                let elem = unsafe { n1.data().get_unchecked(ctx, generator, &idx, None) };
                unsafe { out.data().set_unchecked(ctx, generator, &idx, elem) };
                Ok(())
            },
            llvm_usize.const_int(1, false),
        )?;
        Ok(out.as_base_value().into())
    } else {
        codegen_unreachable!(
            ctx,
            "{FN_NAME}() not supported for '{}'",
            format!("'{}'", ctx.unifier.stringify(x1_ty))
        )
    }
 }
 /// Generates LLVM IR for `ndarray.dot`.
 /// Calculate inner product of two vectors or literals
 /// For matrix multiplication use `np_matmul`
 ///
 /// The input `NDArray` are flattened and treated as 1D
 /// The operation is equivalent to `np.dot(arr1.ravel(), arr2.ravel())`
 pub fn ndarray_dot<'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 = "ndarray_dot";
    let (x1_ty, x1) = x1;
    let (_, x2) = x2;
    let llvm_usize = generator.get_size_type(ctx.ctx);
    match (x1, x2) {
        (BasicValueEnum::PointerValue(n1), BasicValueEnum::PointerValue(n2)) => {
            let n1 = NDArrayValue::from_ptr_val(n1, llvm_usize, None);
            let n2 = NDArrayValue::from_ptr_val(n2, llvm_usize, None);
            let n1_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None));
            let n2_sz = call_ndarray_calc_size(generator, ctx, &n1.dim_sizes(), (None, None));
            ctx.make_assert(
                generator,
                ctx.builder.build_int_compare(IntPredicate::EQ, n1_sz, n2_sz, "").unwrap(),
                "0:ValueError",
                "shapes ({0}), ({1}) not aligned",
                [Some(n1_sz), Some(n2_sz), None],
                ctx.current_loc,
            );
            let identity =
                unsafe { n1.data().get_unchecked(ctx, generator, &llvm_usize.const_zero(), None) };
            let acc = ctx.builder.build_alloca(identity.get_type(), "").unwrap();
            ctx.builder.build_store(acc, identity.get_type().const_zero()).unwrap();
            gen_for_callback_incrementing(
                generator,
                ctx,
                None,
                llvm_usize.const_zero(),
                (n1_sz, false),
                |generator, ctx, _, idx| {
                    let elem1 = unsafe { n1.data().get_unchecked(ctx, generator, &idx, None) };
                    let elem2 = unsafe { n2.data().get_unchecked(ctx, generator, &idx, None) };
                    let product = match elem1 {
                        BasicValueEnum::IntValue(e1) => ctx
                            .builder
                            .build_int_mul(e1, elem2.into_int_value(), "")
                            .unwrap()
                            .as_basic_value_enum(),
                        BasicValueEnum::FloatValue(e1) => ctx
                            .builder
                            .build_float_mul(e1, elem2.into_float_value(), "")
                            .unwrap()
                            .as_basic_value_enum(),
                        _ => codegen_unreachable!(ctx),
                    };
                    let acc_val = ctx.builder.build_load(acc, "").unwrap();
                    let acc_val = match acc_val {
                        BasicValueEnum::IntValue(e1) => ctx
                            .builder
                            .build_int_add(e1, product.into_int_value(), "")
                            .unwrap()
                            .as_basic_value_enum(),
                        BasicValueEnum::FloatValue(e1) => ctx
                            .builder
                            .build_float_add(e1, product.into_float_value(), "")
                            .unwrap()
                            .as_basic_value_enum(),
                        _ => codegen_unreachable!(ctx),
                    };
                    ctx.builder.build_store(acc, acc_val).unwrap();
                    Ok(())
                },
                llvm_usize.const_int(1, false),
            )?;
            let acc_val = ctx.builder.build_load(acc, "").unwrap();
            Ok(acc_val)
        }
        (BasicValueEnum::IntValue(e1), BasicValueEnum::IntValue(e2)) => {
            Ok(ctx.builder.build_int_mul(e1, e2, "").unwrap().as_basic_value_enum())
        }
        (BasicValueEnum::FloatValue(e1), BasicValueEnum::FloatValue(e2)) => {
            Ok(ctx.builder.build_float_mul(e1, e2, "").unwrap().as_basic_value_enum())
        }
        _ => codegen_unreachable!(
            ctx,
            "{FN_NAME}() not supported for '{}'",
            format!("'{}'", ctx.unifier.stringify(x1_ty))
        ),
    }
 }
--- a/nac3core/src/codegen/stmt.rs
+++ b/nac3core/src/codegen/stmt.rs
@ -1,21 +1,3 @@
 use super::{
    super::symbol_resolver::ValueEnum,
    expr::destructure_range,
    irrt::{handle_slice_indices, list_slice_assignment},
    CodeGenContext, CodeGenerator,
 };
 use crate::{
    codegen::{
        classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
        expr::gen_binop_expr,
        gen_in_range_check,
    },
    toplevel::{helper::PrimDef, numpy::unpack_ndarray_var_tys, DefinitionId, TopLevelDef},
    typecheck::{
        magic_methods::Binop,
        typedef::{FunSignature, Type, TypeEnum},
    },
 };
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    basic_block::BasicBlock,
@ -23,10 +5,28 @@ 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;
+
 use super::{
    classes::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
    expr::{destructure_range, gen_binop_expr},
    gen_in_range_check,
    irrt::{handle_slice_indices, list_slice_assignment},
    macros::codegen_unreachable,
    CodeGenContext, CodeGenerator,
 };
 use crate::{
    symbol_resolver::ValueEnum,
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::{
        magic_methods::Binop,
        typedef::{iter_type_vars, FunSignature, Type, TypeEnum},
    },
 };
 /// See [`CodeGenerator::gen_var_alloc`].
 pub fn gen_var<'ctx>(
@ -97,8 +97,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 {
@ -123,7 +121,7 @@ pub fn gen_store_target<'ctx, G: CodeGenerator>(
                return Ok(None);
            };
            let BasicValueEnum::PointerValue(ptr) = val else {
-                unreachable!();
+                codegen_unreachable!(ctx);
            };
            unsafe {
                ctx.builder.build_in_bounds_gep(
@ -137,66 +135,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::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
                    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!(),
    }))
 }
@ -206,70 +145,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::TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
                    *params.iter().next().unwrap().1
                }
                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 {
@ -287,19 +176,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
@ -315,9 +444,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
@ -326,27 +452,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,
@ -363,7 +497,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,
                        ),
@ -393,7 +530,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
@ -431,9 +571,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();
@ -494,6 +639,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,
@ -504,18 +650,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));
@ -572,6 +724,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,
@ -582,7 +735,7 @@ where
    BodyFn: FnOnce(
        &mut G,
        &mut CodeGenContext<'ctx, 'a>,
-        BreakContinueHooks,
+        BreakContinueHooks<'ctx>,
        IntValue<'ctx>,
    ) -> Result<(), String>,
 {
@ -591,6 +744,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();
@ -642,9 +796,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),
@ -656,13 +812,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)?;
@ -720,10 +882,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();
@ -751,7 +913,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
@ -781,7 +943,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)
@ -929,7 +1091,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
@ -1052,11 +1214,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();
@ -1164,7 +1326,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
@ -1241,7 +1403,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);
@ -1513,6 +1675,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();
@ -1523,25 +1702,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();
    }
@ -1575,14 +1735,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 { .. } => {
@ -1596,20 +1756,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(
+            let value_enum = gen_binop_expr(
                generator,
                ctx,
                target,
                Binop::aug_assign(*op),
                value,
                stmt.location,
-            )?;
+            )?
-            generator.gen_assign(ctx, target, value.unwrap())?;
+            .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(());
@ -1633,17 +1817,48 @@ 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],
                stmt.location,
            );
        }
        StmtKind::Global { names, .. } => {
            let registered_globals = ctx
                .top_level
                .definitions
                .read()
                .iter()
                .filter_map(|def| {
                    if let TopLevelDef::Variable { simple_name, ty, .. } = &*def.read() {
                        Some((*simple_name, *ty))
                    } else {
                        None
                    }
                })
                .collect_vec();
            for id in names {
                let Some((_, ty)) = registered_globals.iter().find(|(name, _)| name == id) else {
                    return Err(format!("{id} is not a global at {}", stmt.location));
                };
                let resolver = ctx.resolver.clone();
                let ptr = resolver
                    .get_symbol_value(*id, ctx, generator)
                    .map(|val| val.to_basic_value_enum(ctx, generator, *ty))
                    .transpose()?
                    .map(BasicValueEnum::into_pointer_value)
                    .unwrap();
                ctx.var_assignment.insert(*id, (ptr, None, 0));
            }
        }
        _ => unimplemented!(),
    };
    Ok(())
--- a/nac3core/src/codegen/test.rs
+++ b/nac3core/src/codegen/test.rs
@ -1,34 +1,37 @@
-use crate::{
+use std::{
-    codegen::{
+    collections::{HashMap, HashSet},
-        classes::{ListType, NDArrayType, ProxyType, RangeType},
+    sync::Arc,
        concrete_type::ConcreteTypeStore,
        CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask,
        CodeGenerator, DefaultCodeGenerator, WithCall, WorkerRegistry,
    },
    symbol_resolver::{SymbolResolver, ValueEnum},
    toplevel::{
        composer::{ComposerConfig, TopLevelComposer},
        DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
    },
    typecheck::{
        type_inferencer::{FunctionData, Inferencer, PrimitiveStore},
        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
    },
 };
 use indexmap::IndexMap;
 use indoc::indoc;
 use inkwell::{
    targets::{InitializationConfig, Target},
    OptimizationLevel,
 };
 use nac3parser::ast::FileName;
 use nac3parser::{
-    ast::{fold::Fold, StrRef},
+    ast::{fold::Fold, FileName, StrRef},
    parser::parse_program,
 };
 use parking_lot::RwLock;
-use std::collections::{HashMap, HashSet};
+
-use std::sync::Arc;
+use super::{
    classes::{ListType, NDArrayType, ProxyType, RangeType},
    concrete_type::ConcreteTypeStore,
    CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator,
    DefaultCodeGenerator, WithCall, WorkerRegistry,
 };
 use crate::{
    symbol_resolver::{SymbolResolver, ValueEnum},
    toplevel::{
        composer::{ComposerConfig, TopLevelComposer},
        DefinitionId, FunInstance, TopLevelContext, TopLevelDef,
    },
    typecheck::{
        type_inferencer::{FunctionData, IdentifierInfo, Inferencer, PrimitiveStore},
        typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
    },
 };
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
@ -64,6 +67,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -94,7 +98,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 +113,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(),
@ -128,7 +142,8 @@ fn test_primitives() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "b".into()].into();
+    let mut identifiers: HashMap<_, _> =
        ["a".into(), "b".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
@ -189,6 +204,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 +263,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(),
    };
@ -300,7 +322,8 @@ fn test_simple_call() {
    };
    let mut virtual_checks = Vec::new();
    let mut calls = HashMap::new();
-    let mut identifiers: HashSet<_> = ["a".into(), "foo".into()].into();
+    let mut identifiers: HashMap<_, _> =
        ["a".into(), "foo".into()].map(|id| (id, IdentifierInfo::default())).into();
    let mut inferencer = Inferencer {
        top_level: &top_level,
        function_data: &mut function_data,
@ -368,6 +391,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
@ -1,7 +1,15 @@
-use std::fmt::Debug;
+use std::{
-use std::rc::Rc;
+    collections::{HashMap, HashSet},
-use std::sync::Arc;
+    fmt::{Debug, Display},
-use std::{collections::HashMap, collections::HashSet, fmt::Display};
+    rc::Rc,
    sync::Arc,
 };
 use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
 use itertools::{chain, izip, Itertools};
 use parking_lot::RwLock;
 use nac3parser::ast::{Constant, Expr, Location, StrRef};
 use crate::{
    codegen::{CodeGenContext, CodeGenerator},
@ -11,10 +19,6 @@ use crate::{
        typedef::{Type, TypeEnum, Unifier, VarMap},
    },
 };
 use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
 use itertools::{chain, izip, Itertools};
 use nac3parser::ast::{Constant, Expr, Location, StrRef};
 use parking_lot::RwLock;
 #[derive(Clone, PartialEq, Debug)]
 pub enum SymbolValue {
@ -78,14 +82,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 +159,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,
        }
@ -365,6 +369,7 @@ pub trait SymbolResolver {
        &self,
        str: StrRef,
        ctx: &mut CodeGenContext<'ctx, '_>,
        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>>;
    fn get_default_param_value(&self, expr: &Expr) -> Option<SymbolValue>;
@ -482,7 +487,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
@ -1,6 +1,5 @@
 use std::iter::once;
 use helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDefDetails};
 use indexmap::IndexMap;
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
@ -11,22 +10,22 @@ use inkwell::{
 use itertools::Either;
 use strum::IntoEnumIterator;
 use super::{
    helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDef, PrimDefDetails},
    numpy::make_ndarray_ty,
    *,
 };
 use crate::{
    codegen::{
        builtin_fns,
-        classes::{ArrayLikeValue, NDArrayValue, ProxyValue, RangeValue, TypedArrayLikeAccessor},
+        classes::{ProxyValue, RangeValue},
        expr::destructure_range,
        irrt::*,
        numpy::*,
        stmt::exn_constructor,
    },
    symbol_resolver::SymbolValue,
    toplevel::{helper::PrimDef, numpy::make_ndarray_ty},
    typecheck::typedef::{into_var_map, iter_type_vars, TypeVar, VarMap},
 };
 use super::*;
 type BuiltinInfo = Vec<(Arc<RwLock<TopLevelDef>>, Option<Stmt>)>;
 pub fn get_exn_constructor(
@ -45,10 +44,26 @@ pub fn get_exn_constructor(
            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,
        },
        FuncArg { name: "param0".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
        FuncArg { name: "param1".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
        FuncArg { name: "param2".into(), ty: int64, default_value: Some(SymbolValue::I64(0)) },
    ];
    let exn_type = unifier.add_ty(TypeEnum::TObj {
        obj_id: DefinitionId(class_id),
@ -114,7 +129,12 @@ fn create_fn_by_codegen(
        signature: unifier.add_ty(TypeEnum::TFunc(FunSignature {
            args: param_ty
                .iter()
-                .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                .map(|p| FuncArg {
                    name: p.1.into(),
                    ty: p.0,
                    default_value: None,
                    is_vararg: false,
                })
                .collect(),
            ret: ret_ty,
            vars: var_map.clone(),
@ -346,8 +366,8 @@ impl<'a> BuiltinBuilder<'a> {
        let (is_some_ty, unwrap_ty, option_tvar) =
            if let TypeEnum::TObj { fields, params, .. } = unifier.get_ty(option).as_ref() {
                (
-                    *fields.get(&PrimDef::OptionIsSome.simple_name().into()).unwrap(),
+                    *fields.get(&PrimDef::FunOptionIsSome.simple_name().into()).unwrap(),
-                    *fields.get(&PrimDef::OptionUnwrap.simple_name().into()).unwrap(),
+                    *fields.get(&PrimDef::FunOptionUnwrap.simple_name().into()).unwrap(),
                    iter_type_vars(params).next().unwrap(),
                )
            } else {
@ -362,9 +382,9 @@ impl<'a> BuiltinBuilder<'a> {
        let ndarray_dtype_tvar = iter_type_vars(ndarray_params).next().unwrap();
        let ndarray_ndims_tvar = iter_type_vars(ndarray_params).nth(1).unwrap();
        let ndarray_copy_ty =
-            *ndarray_fields.get(&PrimDef::NDArrayCopy.simple_name().into()).unwrap();
+            *ndarray_fields.get(&PrimDef::FunNDArrayCopy.simple_name().into()).unwrap();
        let ndarray_fill_ty =
-            *ndarray_fields.get(&PrimDef::NDArrayFill.simple_name().into()).unwrap();
+            *ndarray_fields.get(&PrimDef::FunNDArrayFill.simple_name().into()).unwrap();
        let num_ty = unifier.get_fresh_var_with_range(
            &[int32, int64, float, boolean, uint32, uint64],
@ -464,14 +484,14 @@ impl<'a> BuiltinBuilder<'a> {
            PrimDef::Exception => self.build_exception_class_related(prim),
            PrimDef::Option
-            | PrimDef::OptionIsSome
+            | PrimDef::FunOptionIsSome
-            | PrimDef::OptionIsNone
+            | PrimDef::FunOptionIsNone
-            | PrimDef::OptionUnwrap
+            | PrimDef::FunOptionUnwrap
            | PrimDef::FunSome => self.build_option_class_related(prim),
            PrimDef::List => self.build_list_class_related(prim),
-            PrimDef::NDArray | PrimDef::NDArrayCopy | PrimDef::NDArrayFill => {
+            PrimDef::NDArray | PrimDef::FunNDArrayCopy | PrimDef::FunNDArrayFill => {
                self.build_ndarray_class_related(prim)
            }
@ -510,7 +530,9 @@ impl<'a> BuiltinBuilder<'a> {
            PrimDef::FunMin | PrimDef::FunMax => self.build_min_max_function(prim),
-            PrimDef::FunNpMin | PrimDef::FunNpMax => self.build_np_min_max_function(prim),
+            PrimDef::FunNpArgmin | PrimDef::FunNpArgmax | PrimDef::FunNpMin | PrimDef::FunNpMax => {
                self.build_np_max_min_function(prim)
            }
            PrimDef::FunNpMinimum | PrimDef::FunNpMaximum => {
                self.build_np_minimum_maximum_function(prim)
@ -554,6 +576,22 @@ impl<'a> BuiltinBuilder<'a> {
            | PrimDef::FunNpLdExp
            | PrimDef::FunNpHypot
            | PrimDef::FunNpNextAfter => self.build_np_2ary_function(prim),
            PrimDef::FunNpTranspose | PrimDef::FunNpReshape => {
                self.build_np_sp_ndarray_function(prim)
            }
            PrimDef::FunNpDot
            | PrimDef::FunNpLinalgCholesky
            | PrimDef::FunNpLinalgQr
            | PrimDef::FunNpLinalgSvd
            | PrimDef::FunNpLinalgInv
            | PrimDef::FunNpLinalgPinv
            | PrimDef::FunNpLinalgMatrixPower
            | PrimDef::FunNpLinalgDet
            | PrimDef::FunSpLinalgLu
            | PrimDef::FunSpLinalgSchur
            | PrimDef::FunSpLinalgHessenberg => self.build_linalg_methods(prim),
        };
        if cfg!(debug_assertions) {
@ -562,7 +600,7 @@ impl<'a> BuiltinBuilder<'a> {
            match (&tld, prim.details()) {
                (
                    TopLevelDef::Class { name, object_id, .. },
-                    PrimDefDetails::PrimClass { name: exp_name },
+                    PrimDefDetails::PrimClass { name: exp_name, .. },
                ) => {
                    let exp_object_id = prim.id();
                    assert_eq!(name, &exp_name.into());
@ -611,17 +649,24 @@ impl<'a> BuiltinBuilder<'a> {
        let make_ctor_signature = |unifier: &mut Unifier| {
            unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: vec![
-                    FuncArg { name: "start".into(), ty: int32, default_value: None },
+                    FuncArg {
                        name: "start".into(),
                        ty: int32,
                        default_value: None,
                        is_vararg: false,
                    },
                    FuncArg {
                        name: "stop".into(),
                        ty: int32,
                        // placeholder
                        default_value: Some(SymbolValue::I32(0)),
                        is_vararg: false,
                    },
                    FuncArg {
                        name: "step".into(),
                        ty: int32,
                        default_value: Some(SymbolValue::I32(1)),
                        is_vararg: false,
                    },
                ],
                ret: range,
@ -792,9 +837,9 @@ impl<'a> BuiltinBuilder<'a> {
            prim,
            &[
                PrimDef::Option,
-                PrimDef::OptionIsSome,
+                PrimDef::FunOptionIsSome,
-                PrimDef::OptionIsNone,
+                PrimDef::FunOptionIsNone,
-                PrimDef::OptionUnwrap,
+                PrimDef::FunOptionUnwrap,
                PrimDef::FunSome,
            ],
        );
@ -807,9 +852,9 @@ impl<'a> BuiltinBuilder<'a> {
                fields: Vec::default(),
                attributes: Vec::default(),
                methods: vec![
-                    Self::create_method(PrimDef::OptionIsSome, self.is_some_ty.0),
+                    Self::create_method(PrimDef::FunOptionIsSome, self.is_some_ty.0),
-                    Self::create_method(PrimDef::OptionIsNone, self.is_some_ty.0),
+                    Self::create_method(PrimDef::FunOptionIsNone, self.is_some_ty.0),
-                    Self::create_method(PrimDef::OptionUnwrap, self.unwrap_ty.0),
+                    Self::create_method(PrimDef::FunOptionUnwrap, self.unwrap_ty.0),
                ],
                ancestors: vec![TypeAnnotation::CustomClass {
                    id: prim.id(),
@ -820,7 +865,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },
-            PrimDef::OptionUnwrap => TopLevelDef::Function {
+            PrimDef::FunOptionUnwrap => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.unwrap_ty.0,
@ -834,7 +879,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },
-            PrimDef::OptionIsNone | PrimDef::OptionIsSome => TopLevelDef::Function {
+            PrimDef::FunOptionIsNone | PrimDef::FunOptionIsSome => TopLevelDef::Function {
                name: prim.name().to_string(),
                simple_name: prim.simple_name().into(),
                signature: self.is_some_ty.0,
@ -855,10 +900,10 @@ impl<'a> BuiltinBuilder<'a> {
                        };
                        let returned_int = match prim {
-                            PrimDef::OptionIsNone => {
+                            PrimDef::FunOptionIsNone => {
                                ctx.builder.build_is_null(ptr, prim.simple_name())
                            }
-                            PrimDef::OptionIsSome => {
+                            PrimDef::FunOptionIsSome => {
                                ctx.builder.build_is_not_null(ptr, prim.simple_name())
                            }
                            _ => unreachable!(),
@ -877,6 +922,7 @@ impl<'a> BuiltinBuilder<'a> {
                        name: "n".into(),
                        ty: self.option_tvar.ty,
                        default_value: None,
                        is_vararg: false,
                    }],
                    ret: self.primitives.option,
                    vars: into_var_map([self.option_tvar]),
@ -931,7 +977,7 @@ impl<'a> BuiltinBuilder<'a> {
    fn build_ndarray_class_related(&self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(
            prim,
-            &[PrimDef::NDArray, PrimDef::NDArrayCopy, PrimDef::NDArrayFill],
+            &[PrimDef::NDArray, PrimDef::FunNDArrayCopy, PrimDef::FunNDArrayFill],
        );
        match prim {
@ -942,8 +988,8 @@ impl<'a> BuiltinBuilder<'a> {
                fields: Vec::default(),
                attributes: Vec::default(),
                methods: vec![
-                    Self::create_method(PrimDef::NDArrayCopy, self.ndarray_copy_ty.0),
+                    Self::create_method(PrimDef::FunNDArrayCopy, self.ndarray_copy_ty.0),
-                    Self::create_method(PrimDef::NDArrayFill, self.ndarray_fill_ty.0),
+                    Self::create_method(PrimDef::FunNDArrayFill, self.ndarray_fill_ty.0),
                ],
                ancestors: Vec::default(),
                constructor: None,
@ -951,7 +997,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },
-            PrimDef::NDArrayCopy => TopLevelDef::Function {
+            PrimDef::FunNDArrayCopy => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.ndarray_copy_ty.0,
@ -968,7 +1014,7 @@ impl<'a> BuiltinBuilder<'a> {
                loc: None,
            },
-            PrimDef::NDArrayFill => TopLevelDef::Function {
+            PrimDef::FunNDArrayFill => TopLevelDef::Function {
                name: prim.name().into(),
                simple_name: prim.simple_name().into(),
                signature: self.ndarray_fill_ty.0,
@ -1011,6 +1057,7 @@ impl<'a> BuiltinBuilder<'a> {
                    name: "n".into(),
                    ty: self.num_or_ndarray_ty.ty,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: self.num_or_ndarray_ty.ty,
                vars: self.num_or_ndarray_var_map.clone(),
@ -1230,16 +1277,23 @@ impl<'a> BuiltinBuilder<'a> {
                    simple_name: prim.simple_name().into(),
                    signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        args: vec![
-                            FuncArg { name: "object".into(), ty: tv.ty, default_value: None },
+                            FuncArg {
                                name: "object".into(),
                                ty: tv.ty,
                                default_value: None,
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "copy".into(),
                                ty: bool,
                                default_value: Some(SymbolValue::Bool(true)),
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "ndmin".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::U32(0)),
                                is_vararg: false,
                            },
                        ],
                        ret: ndarray,
@ -1281,17 +1335,24 @@ impl<'a> BuiltinBuilder<'a> {
                    simple_name: prim.simple_name().into(),
                    signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                        args: vec![
-                            FuncArg { name: "N".into(), ty: int32, default_value: None },
+                            FuncArg {
                                name: "N".into(),
                                ty: int32,
                                default_value: None,
                                is_vararg: false,
                            },
                            // TODO(Derppening): Default values current do not work?
                            FuncArg {
                                name: "M".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::OptionNone),
                                is_vararg: false,
                            },
                            FuncArg {
                                name: "k".into(),
                                ty: int32,
                                default_value: Some(SymbolValue::I32(0)),
                                is_vararg: false,
                            },
                        ],
                        ret: self.ndarray_float_2d,
@ -1335,7 +1396,12 @@ impl<'a> BuiltinBuilder<'a> {
            name: prim.name().into(),
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "s".into(), ty: str, default_value: None }],
+                args: vec![FuncArg {
                    name: "s".into(),
                    ty: str,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: str,
                vars: VarMap::default(),
            })),
@ -1399,31 +1465,21 @@ impl<'a> BuiltinBuilder<'a> {
    fn build_len_function(&mut self) -> TopLevelDef {
        let prim = PrimDef::FunLen;
-        let PrimitiveStore { uint64, int32, .. } = *self.primitives;
+        // Type handled in [`Inferencer::try_fold_special_call`]
        let arg_tvar = self.unifier.get_dummy_var();
        let tvar = self.unifier.get_fresh_var(Some("L".into()), None);
        let list = self
            .unifier
            .subst(
                self.primitives.list,
                &into_var_map([TypeVar { id: self.list_tvar.id, ty: tvar.ty }]),
            )
            .unwrap();
        let ndims = self.unifier.get_fresh_const_generic_var(uint64, Some("N".into()), None);
        let ndarray = make_ndarray_ty(self.unifier, self.primitives, Some(tvar.ty), Some(ndims.ty));
        let arg_ty = self.unifier.get_fresh_var_with_range(
            &[list, ndarray, self.primitives.range],
            Some("I".into()),
            None,
        );
        TopLevelDef::Function {
            name: prim.name().into(),
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
-                args: vec![FuncArg { name: "ls".into(), ty: arg_ty.ty, default_value: None }],
+                args: vec![FuncArg {
-                ret: int32,
+                    name: "obj".into(),
-                vars: into_var_map([tvar, arg_ty]),
+                    ty: arg_tvar.ty,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: self.primitives.int32,
                vars: into_var_map([arg_tvar]),
            })),
            var_id: Vec::default(),
            instance_to_symbol: HashMap::default(),
@ -1431,86 +1487,10 @@ impl<'a> BuiltinBuilder<'a> {
            resolver: None,
            codegen_callback: Some(Arc::new(GenCall::new(Box::new(
                move |ctx, _, fun, args, generator| {
                    let range_ty = ctx.primitives.range;
                    let arg_ty = fun.0.args[0].ty;
                    let arg = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
                    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);
                        Some(calculate_len_for_slice_range(generator, ctx, start, end, step).into())
                    } else {
                        match &*ctx.unifier.get_ty_immutable(arg_ty) {
                            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::List.id() => {
                                let int32 = ctx.ctx.i32_type();
                                let zero = int32.const_zero();
                                let len = ctx
                                    .build_gep_and_load(
                                        arg.into_pointer_value(),
                                        &[zero, int32.const_int(1, false)],
                                        None,
                                    )
                                    .into_int_value();
                                if len.get_type().get_bit_width() == 32 {
                                    Some(len.into())
                                } else {
                                    Some(
                                        ctx.builder
                                            .build_int_truncate(len, int32, "len2i32")
                                            .map(Into::into)
                                            .unwrap(),
                                    )
                                }
                            }
                            TypeEnum::TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
                                let llvm_i32 = ctx.ctx.i32_type();
                                let llvm_usize = generator.get_size_type(ctx.ctx);
-                                let arg = NDArrayValue::from_ptr_val(
+                    builtin_fns::call_len(generator, ctx, (arg_ty, arg)).map(|ret| Some(ret.into()))
                                    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",
                                    &format!("{name}() of unsized object", name = prim.name()),
                                    [None, None, None],
                                    ctx.current_loc,
                                );
                                let len = unsafe {
                                    arg.dim_sizes().get_typed_unchecked(
                                        ctx,
                                        generator,
                                        &llvm_usize.const_zero(),
                                        None,
                                    )
                                };
                                if len.get_type().get_bit_width() == 32 {
                                    Some(len.into())
                                } else {
                                    Some(
                                        ctx.builder
                                            .build_int_truncate(len, llvm_i32, "len")
                                            .map(Into::into)
                                            .unwrap(),
                                    )
                                }
                            }
                            _ => unreachable!(),
                        }
                    })
                },
            )))),
            loc: None,
@ -1526,8 +1506,18 @@ impl<'a> BuiltinBuilder<'a> {
            simple_name: prim.simple_name().into(),
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: vec![
-                    FuncArg { name: "m".into(), ty: self.num_ty.ty, default_value: None },
+                    FuncArg {
-                    FuncArg { name: "n".into(), ty: self.num_ty.ty, default_value: None },
+                        name: "m".into(),
                        ty: self.num_ty.ty,
                        default_value: None,
                        is_vararg: false,
                    },
                    FuncArg {
                        name: "n".into(),
                        ty: self.num_ty.ty,
                        default_value: None,
                        is_vararg: false,
                    },
                ],
                ret: self.num_ty.ty,
                vars: self.num_var_map.clone(),
@ -1555,10 +1545,19 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }
-    /// Build the functions `np_min()` and `np_max()`.
+    /// Build the functions `np_max()`, `np_min()`, `np_argmax()` and `np_argmin()`
-    fn build_np_min_max_function(&mut self, prim: PrimDef) -> TopLevelDef {
+    /// Calls `call_numpy_max_min` with the function name
-        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpMin, PrimDef::FunNpMax]);
+    fn build_np_max_min_function(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(
            prim,
            &[PrimDef::FunNpArgmin, PrimDef::FunNpArgmax, PrimDef::FunNpMin, PrimDef::FunNpMax],
        );
        let (var_map, ret_ty) = match prim {
            PrimDef::FunNpArgmax | PrimDef::FunNpArgmin => {
                (self.num_or_ndarray_var_map.clone(), self.primitives.int64)
            }
            PrimDef::FunNpMax | PrimDef::FunNpMin => {
                let ret_ty = self.unifier.get_fresh_var(Some("R".into()), None);
                let var_map = self
                    .num_or_ndarray_var_map
@ -1566,28 +1565,25 @@ impl<'a> BuiltinBuilder<'a> {
                    .into_iter()
                    .chain(once((ret_ty.id, ret_ty.ty)))
                    .collect::<IndexMap<_, _>>();
                (var_map, ret_ty.ty)
            }
            _ => unreachable!(),
        };
        create_fn_by_codegen(
            self.unifier,
            &var_map,
            prim.name(),
-            ret_ty.ty,
+            ret_ty,
-            &[(self.float_or_ndarray_ty.ty, "a")],
+            &[(self.num_or_ndarray_ty.ty, "a")],
            Box::new(move |ctx, _, fun, args, generator| {
                let a_ty = fun.0.args[0].ty;
                let a = args[0].1.clone().to_basic_value_enum(ctx, generator, a_ty)?;
-                let func = match prim {
+                Ok(Some(builtin_fns::call_numpy_max_min(generator, ctx, (a_ty, a), prim.name())?))
                    PrimDef::FunNpMin => builtin_fns::call_numpy_min,
                    PrimDef::FunNpMax => builtin_fns::call_numpy_max,
                    _ => unreachable!(),
                };
                Ok(Some(func(generator, ctx, (a_ty, a))?))
            }),
        )
    }
    /// Build the functions `np_minimum()` and `np_maximum()`.
    fn build_np_minimum_maximum_function(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpMinimum, PrimDef::FunNpMaximum]);
@ -1603,7 +1599,12 @@ impl<'a> BuiltinBuilder<'a> {
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: param_ty
                    .iter()
-                    .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                    .map(|p| FuncArg {
                        name: p.1.into(),
                        ty: p.0,
                        default_value: None,
                        is_vararg: false,
                    })
                    .collect(),
                ret: ret_ty.ty,
                vars: into_var_map([x1_ty, x2_ty, ret_ty]),
@ -1644,6 +1645,7 @@ impl<'a> BuiltinBuilder<'a> {
                    name: "n".into(),
                    ty: self.num_or_ndarray_ty.ty,
                    default_value: None,
                    is_vararg: false,
                }],
                ret: self.num_or_ndarray_ty.ty,
                vars: self.num_or_ndarray_var_map.clone(),
@ -1832,7 +1834,12 @@ impl<'a> BuiltinBuilder<'a> {
            signature: self.unifier.add_ty(TypeEnum::TFunc(FunSignature {
                args: param_ty
                    .iter()
-                    .map(|p| FuncArg { name: p.1.into(), ty: p.0, default_value: None })
+                    .map(|p| FuncArg {
                        name: p.1.into(),
                        ty: p.0,
                        default_value: None,
                        is_vararg: false,
                    })
                    .collect(),
                ret: ret_ty.ty,
                vars: into_var_map([x1_ty, x2_ty, ret_ty]),
@ -1866,6 +1873,207 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }
    /// Build np/sp functions that take as input `NDArray` only
    fn build_np_sp_ndarray_function(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpTranspose, PrimDef::FunNpReshape]);
        match prim {
            PrimDef::FunNpTranspose => {
                let ndarray_ty = self.unifier.get_fresh_var_with_range(
                    &[self.ndarray_num_ty],
                    Some("T".into()),
                    None,
                );
                create_fn_by_codegen(
                    self.unifier,
                    &into_var_map([ndarray_ty]),
                    prim.name(),
                    ndarray_ty.ty,
                    &[(ndarray_ty.ty, "x")],
                    Box::new(move |ctx, _, fun, args, generator| {
                        let arg_ty = fun.0.args[0].ty;
                        let arg_val =
                            args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
                        Ok(Some(ndarray_transpose(generator, ctx, (arg_ty, arg_val))?))
                    }),
                )
            }
            // NOTE: on `ndarray_factory_fn_shape_arg_tvar` and
            // the `param_ty` for `create_fn_by_codegen`.
            //
            // Similar to `build_ndarray_from_shape_factory_function` we delegate the responsibility of typechecking
            // to [`typecheck::type_inferencer::Inferencer::fold_numpy_function_call_shape_argument`],
            // and use a dummy [`TypeVar`] `ndarray_factory_fn_shape_arg_tvar` as a placeholder for `param_ty`.
            PrimDef::FunNpReshape => create_fn_by_codegen(
                self.unifier,
                &VarMap::new(),
                prim.name(),
                self.ndarray_num_ty,
                &[(self.ndarray_num_ty, "x"), (self.ndarray_factory_fn_shape_arg_tvar.ty, "shape")],
                Box::new(move |ctx, _, fun, args, generator| {
                    let x1_ty = fun.0.args[0].ty;
                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                    let x2_ty = fun.0.args[1].ty;
                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
                    Ok(Some(ndarray_reshape(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
                }),
            ),
            _ => unreachable!(),
        }
    }
    /// Build `np_linalg` and `sp_linalg` functions
    ///
    /// The input to these functions must be floating point `NDArray`
    fn build_linalg_methods(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(
            prim,
            &[
                PrimDef::FunNpDot,
                PrimDef::FunNpLinalgCholesky,
                PrimDef::FunNpLinalgQr,
                PrimDef::FunNpLinalgSvd,
                PrimDef::FunNpLinalgInv,
                PrimDef::FunNpLinalgPinv,
                PrimDef::FunNpLinalgMatrixPower,
                PrimDef::FunNpLinalgDet,
                PrimDef::FunSpLinalgLu,
                PrimDef::FunSpLinalgSchur,
                PrimDef::FunSpLinalgHessenberg,
            ],
        );
        match prim {
            PrimDef::FunNpDot => create_fn_by_codegen(
                self.unifier,
                &self.num_or_ndarray_var_map,
                prim.name(),
                self.num_ty.ty,
                &[(self.num_or_ndarray_ty.ty, "x1"), (self.num_or_ndarray_ty.ty, "x2")],
                Box::new(move |ctx, _, fun, args, generator| {
                    let x1_ty = fun.0.args[0].ty;
                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                    let x2_ty = fun.0.args[1].ty;
                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
                    Ok(Some(ndarray_dot(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
                }),
            ),
            PrimDef::FunNpLinalgCholesky | PrimDef::FunNpLinalgInv | PrimDef::FunNpLinalgPinv => {
                create_fn_by_codegen(
                    self.unifier,
                    &VarMap::new(),
                    prim.name(),
                    self.ndarray_float_2d,
                    &[(self.ndarray_float_2d, "x1")],
                    Box::new(move |ctx, _, fun, args, generator| {
                        let x1_ty = fun.0.args[0].ty;
                        let x1_val =
                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                        let func = match prim {
                            PrimDef::FunNpLinalgCholesky => builtin_fns::call_np_linalg_cholesky,
                            PrimDef::FunNpLinalgInv => builtin_fns::call_np_linalg_inv,
                            PrimDef::FunNpLinalgPinv => builtin_fns::call_np_linalg_pinv,
                            _ => unreachable!(),
                        };
                        Ok(Some(func(generator, ctx, (x1_ty, x1_val))?))
                    }),
                )
            }
            PrimDef::FunNpLinalgQr
            | PrimDef::FunSpLinalgLu
            | PrimDef::FunSpLinalgSchur
            | PrimDef::FunSpLinalgHessenberg => {
                let ret_ty = self.unifier.add_ty(TypeEnum::TTuple {
                    ty: vec![self.ndarray_float_2d, self.ndarray_float_2d],
                    is_vararg_ctx: false,
                });
                create_fn_by_codegen(
                    self.unifier,
                    &VarMap::new(),
                    prim.name(),
                    ret_ty,
                    &[(self.ndarray_float_2d, "x1")],
                    Box::new(move |ctx, _, fun, args, generator| {
                        let x1_ty = fun.0.args[0].ty;
                        let x1_val =
                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                        let func = match prim {
                            PrimDef::FunNpLinalgQr => builtin_fns::call_np_linalg_qr,
                            PrimDef::FunSpLinalgLu => builtin_fns::call_sp_linalg_lu,
                            PrimDef::FunSpLinalgSchur => builtin_fns::call_sp_linalg_schur,
                            PrimDef::FunSpLinalgHessenberg => {
                                builtin_fns::call_sp_linalg_hessenberg
                            }
                            _ => unreachable!(),
                        };
                        Ok(Some(func(generator, ctx, (x1_ty, x1_val))?))
                    }),
                )
            }
            PrimDef::FunNpLinalgSvd => {
                let ret_ty = self.unifier.add_ty(TypeEnum::TTuple {
                    ty: vec![self.ndarray_float_2d, self.ndarray_float, self.ndarray_float_2d],
                    is_vararg_ctx: false,
                });
                create_fn_by_codegen(
                    self.unifier,
                    &VarMap::new(),
                    prim.name(),
                    ret_ty,
                    &[(self.ndarray_float_2d, "x1")],
                    Box::new(move |ctx, _, fun, args, generator| {
                        let x1_ty = fun.0.args[0].ty;
                        let x1_val =
                            args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                        Ok(Some(builtin_fns::call_np_linalg_svd(generator, ctx, (x1_ty, x1_val))?))
                    }),
                )
            }
            PrimDef::FunNpLinalgMatrixPower => create_fn_by_codegen(
                self.unifier,
                &VarMap::new(),
                prim.name(),
                self.ndarray_float_2d,
                &[(self.ndarray_float_2d, "x1"), (self.primitives.int32, "power")],
                Box::new(move |ctx, _, fun, args, generator| {
                    let x1_ty = fun.0.args[0].ty;
                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                    let x2_ty = fun.0.args[1].ty;
                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
                    Ok(Some(builtin_fns::call_np_linalg_matrix_power(
                        generator,
                        ctx,
                        (x1_ty, x1_val),
                        (x2_ty, x2_val),
                    )?))
                }),
            ),
            PrimDef::FunNpLinalgDet => create_fn_by_codegen(
                self.unifier,
                &VarMap::new(),
                prim.name(),
                self.primitives.float,
                &[(self.ndarray_float_2d, "x1")],
                Box::new(move |ctx, _, fun, args, generator| {
                    let x1_ty = fun.0.args[0].ty;
                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
                    Ok(Some(builtin_fns::call_np_linalg_det(generator, ctx, (x1_ty, x1_val))?))
                }),
            ),
            _ => unreachable!(),
        }
    }
    fn create_method(prim: PrimDef, method_ty: Type) -> (StrRef, Type, DefinitionId) {
        (prim.simple_name().into(), method_ty, prim.id())
    }
--- a/nac3core/src/toplevel/composer.rs
+++ b/nac3core/src/toplevel/composer.rs
@ -1,17 +1,17 @@
 use nac3parser::ast::fold::Fold;
 use std::rc::Rc;
 use nac3parser::ast::{fold::Fold, ExprKind, Ident};
 use super::*;
 use crate::{
    codegen::{expr::get_subst_key, stmt::exn_constructor},
    symbol_resolver::SymbolValue,
    typecheck::{
-        type_inferencer::{FunctionData, Inferencer},
+        type_inferencer::{FunctionData, IdentifierInfo, Inferencer},
        typedef::{TypeVar, VarMap},
    },
 };
 use super::*;
 pub struct ComposerConfig {
    pub kernel_ann: Option<&'static str>,
    pub kernel_invariant_ann: &'static str,
@ -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>) {
@ -86,7 +101,8 @@ impl TopLevelComposer {
            .iter()
            .map(|def_ast| match *def_ast.0.read() {
                TopLevelDef::Class { name, .. } => name.to_string(),
-                TopLevelDef::Function { simple_name, .. } => simple_name.to_string(),
+                TopLevelDef::Function { simple_name, .. }
                | TopLevelDef::Variable { simple_name, .. } => simple_name.to_string(),
            })
            .collect_vec();
@ -119,7 +135,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()));
@ -360,13 +382,87 @@ impl TopLevelComposer {
                ))
            }
            ast::StmtKind::Assign { .. } => {
                // Assignment statements can assign to (and therefore create) more than one 
                // variable, but this function only allows returning one set of symbol information.
                // We want to avoid changing this to return a `Vec` of symbol info, as this would 
                // require `iter().next().unwrap()` on every variable created from a non-Assign 
                // statement.
                //
                // Make callers use `register_top_level_var` instead, as it provides more
                // fine-grained control over which symbols to register, while also simplifying the
                // usage of this function.
                panic!("Registration of top-level Assign statements must use TopLevelComposer::register_top_level_var (at {})", ast.location);
            }
            ast::StmtKind::AnnAssign { target, annotation, .. } => {
                let ExprKind::Name { id: name, .. } = target.node else {
                    return Err(format!(
                        "global variable declaration must be an identifier (at {})",
                        target.location
                    ));
                };
                self.register_top_level_var(
                    name,
                    Some(annotation.as_ref().clone()),
                    resolver,
                    mod_path,
                    target.location,
                )
            }
            _ => Err(format!(
-                "registrations of constructs other than top level classes/functions are not supported (at {})",
+                "registrations of constructs other than top level classes/functions/variables are not supported (at {})",
                ast.location
            )),
        }
    }
    /// Registers a top-level variable with the given `name` into the composer.
    ///
    /// `annotation` - The type annotation of the top-level variable, or [`None`] if no type
    /// annotation is provided.
    /// `location` - The location of the top-level variable.
    pub fn register_top_level_var(
        &mut self,
        name: Ident,
        annotation: Option<Expr>,
        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
        mod_path: &str,
        location: Location,
    ) -> Result<(StrRef, DefinitionId, Option<Type>), String> {
        if self.keyword_list.contains(&name) {
            return Err(format!("cannot use keyword `{name}` as a class name (at {location})"));
        }
        let global_var_name =
            if mod_path.is_empty() { name.to_string() } else { format!("{mod_path}.{name}") };
        if !self.defined_names.insert(global_var_name.clone()) {
            return Err(format!(
                "global variable `{global_var_name}` defined twice (at {location})"
            ));
        }
        let ty_to_be_unified = self.unifier.get_dummy_var().ty;
        self.definition_ast_list.push((
            RwLock::new(Self::make_top_level_variable_def(
                global_var_name,
                name,
                // dummy here, unify with correct type later,
                ty_to_be_unified,
                annotation,
                resolver,
                Some(location),
            ))
            .into(),
            None,
        ));
        Ok((name, DefinitionId(self.definition_ast_list.len() - 1), Some(ty_to_be_unified)))
    }
    pub fn start_analysis(&mut self, inference: bool) -> Result<(), HashSet<String>> {
        self.analyze_top_level_class_type_var()?;
        self.analyze_top_level_class_bases()?;
@ -375,6 +471,7 @@ impl TopLevelComposer {
        if inference {
            self.analyze_function_instance()?;
        }
        self.analyze_top_level_variables()?;
        Ok(())
    }
@ -412,7 +509,7 @@ impl TopLevelComposer {
                    // things like `class A(Generic[T, V, ImportedModule.T])` is not supported
                    // i.e. only simple names are allowed in the subscript
                    // should update the TopLevelDef::Class.typevars and the TypeEnum::TObj.params
-                    ast::ExprKind::Subscript { value, slice, .. }
+                    ExprKind::Subscript { value, slice, .. }
                        if {
                            matches!(
                                &value.node,
@ -428,9 +525,9 @@ impl TopLevelComposer {
                        }
                        is_generic = true;
-                        let type_var_list: Vec<&ast::Expr<()>>;
+                        let type_var_list: Vec<&Expr<()>>;
                        // if `class A(Generic[T, V, G])`
-                        if let ast::ExprKind::Tuple { elts, .. } = &slice.node {
+                        if let ExprKind::Tuple { elts, .. } = &slice.node {
                            type_var_list = elts.iter().collect_vec();
                        // `class A(Generic[T])`
                        } else {
@ -479,6 +576,7 @@ impl TopLevelComposer {
            }
            Ok(())
        };
        let mut errors = HashSet::new();
        for (class_def, class_ast) in def_list.iter().skip(self.builtin_num) {
            if class_ast.is_none() {
@ -766,6 +864,7 @@ impl TopLevelComposer {
            let target_ty = get_type_from_type_annotation_kinds(
                &temp_def_list,
                unifier,
                primitives,
                &def,
                &mut subst_list,
            )?;
@ -831,7 +930,6 @@ impl TopLevelComposer {
        let unifier = self.unifier.borrow_mut();
        let primitives_store = &self.primitives_ty;
        let mut errors = HashSet::new();
        let mut analyze = |function_def: &Arc<RwLock<TopLevelDef>>, function_ast: &Option<Stmt>| {
            let mut function_def = function_def.write();
            let function_def = &mut *function_def;
@ -859,7 +957,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 {
@ -874,15 +1038,15 @@ impl TopLevelComposer {
                    }
                }
-                let arg_with_default: Vec<(&ast::Located<ast::ArgData<()>>, Option<&ast::Expr>)> =
+                let arg_with_default: Vec<(&ast::Located<ast::ArgData<()>>, Option<&Expr>)> = args
-                    args.args
+                    .args
                    .iter()
                    .rev()
                    .zip(
                        args.defaults
                            .iter()
                            .rev()
-                                .map(|x| -> Option<&ast::Expr> { Some(x) })
+                            .map(|x| -> Option<&Expr> { Some(x) })
                            .chain(std::iter::repeat(None)),
                    )
                    .collect_vec();
@ -936,6 +1100,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 +1124,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 +1174,7 @@ impl TopLevelComposer {
                    get_type_from_type_annotation_kinds(
                        &temp_def_list,
                        unifier,
                        primitives_store,
                        &return_ty_annotation,
                        &mut None,
                    )?
@ -1031,6 +1204,8 @@ impl TopLevelComposer {
            })?;
            Ok(())
        };
        let mut errors = HashSet::new();
        for (function_def, function_ast) in def_list.iter().skip(self.builtin_num) {
            if function_ast.is_none() {
                continue;
@ -1132,7 +1307,7 @@ impl TopLevelComposer {
                        let arg_with_default: Vec<(
                            &ast::Located<ast::ArgData<()>>,
-                            Option<&ast::Expr>,
+                            Option<&Expr>,
                        )> = args
                            .args
                            .iter()
@ -1141,7 +1316,7 @@ impl TopLevelComposer {
                                args.defaults
                                    .iter()
                                    .rev()
-                                    .map(|x| -> Option<&ast::Expr> { Some(x) })
+                                    .map(|x| -> Option<&Expr> { Some(x) })
                                    .chain(std::iter::repeat(None)),
                            )
                            .collect_vec();
@ -1214,6 +1389,7 @@ impl TopLevelComposer {
                                            })
                                        }
                                    },
                                    is_vararg: false,
                                };
                                // push the dummy type and the type annotation
                                // into the list for later unification
@ -1297,7 +1473,7 @@ impl TopLevelComposer {
                        .map_err(|e| HashSet::from([e.to_display(unifier).to_string()]))?;
                }
                ast::StmtKind::AnnAssign { target, annotation, value, .. } => {
-                    if let ast::ExprKind::Name { id: attr, .. } = &target.node {
+                    if let ExprKind::Name { id: attr, .. } = &target.node {
                        if defined_fields.insert(attr.to_string()) {
                            let dummy_field_type = unifier.get_dummy_var().ty;
@ -1305,7 +1481,7 @@ impl TopLevelComposer {
                                None => {
                                    // handle Kernel[T], KernelInvariant[T]
                                    let (annotation, mutable) = match &annotation.node {
-                                        ast::ExprKind::Subscript { value, slice, .. }
+                                        ExprKind::Subscript { value, slice, .. }
                                            if matches!(
                                                &value.node,
                                                ast::ExprKind::Name { id, .. } if id == &core_config.kernel_invariant_ann.into()
@ -1313,7 +1489,7 @@ impl TopLevelComposer {
                                        {
                                            (slice, false)
                                        }
-                                        ast::ExprKind::Subscript { value, slice, .. }
+                                        ExprKind::Subscript { value, slice, .. }
                                            if matches!(
                                                &value.node,
                                                ast::ExprKind::Name { id, .. } if core_config.kernel_ann.map_or(false, |c| id == &c.into())
@ -1331,13 +1507,13 @@ impl TopLevelComposer {
                                Some(boxed_expr) => {
                                    // Class attributes are set as immutable regardless
                                    let (annotation, _) = match &annotation.node {
-                                        ast::ExprKind::Subscript { slice, .. } => (slice, false),
+                                        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: _ }} => {
+                                        ast::Located {location: _, custom: (), node: 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(_) => {}
@ -1604,7 +1780,6 @@ impl TopLevelComposer {
            }
        }
        let mut errors = HashSet::new();
        let mut analyze = |i, def: &Arc<RwLock<TopLevelDef>>, ast: &Option<Stmt>| {
            let class_def = def.read();
            if let TopLevelDef::Class {
@ -1622,6 +1797,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,
                )?;
@ -1638,21 +1814,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,
@ -1719,7 +1899,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([
@ -1737,6 +1922,8 @@ impl TopLevelComposer {
            }
            Ok(())
        };
        let mut errors = HashSet::new();
        for (i, (def, ast)) in definition_ast_list.iter().enumerate().skip(self.builtin_num) {
            if ast.is_none() {
                continue;
@ -1774,19 +1961,20 @@ impl TopLevelComposer {
            if ast.is_none() {
                return Ok(());
            }
-            let mut function_def = def.write();
+
-            if let TopLevelDef::Function {
+            let (name, simple_name, signature, resolver) = {
-                instance_to_stmt,
+                let function_def = def.read();
-                instance_to_symbol,
+                let TopLevelDef::Function { name, simple_name, signature, resolver, .. } =
-                name,
+                    &*function_def
-                simple_name,
+                else {
-                signature,
+                    return Ok(());
-                resolver,
+                };
-                ..
+
-            } = &mut *function_def
+                (name.clone(), *simple_name, *signature, resolver.clone())
-            {
+            };
-                let signature_ty_enum = unifier.get_ty(*signature);
+
-                let TypeEnum::TFunc(FunSignature { args, ret, vars }) = signature_ty_enum.as_ref()
+            let signature_ty_enum = unifier.get_ty(signature);
            let TypeEnum::TFunc(FunSignature { args, ret, vars, .. }) = signature_ty_enum.as_ref()
            else {
                unreachable!("must be typeenum::tfunc")
            };
@ -1803,7 +1991,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 {
@ -1858,6 +2050,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()
                };
@ -1889,11 +2082,11 @@ impl TopLevelComposer {
                    })
                };
                let mut identifiers = {
-                        let mut result: HashSet<_> = HashSet::new();
+                    let mut result = HashMap::new();
                    if self_type.is_some() {
-                            result.insert("self".into());
+                        result.insert("self".into(), IdentifierInfo::default());
                    }
-                        result.extend(inst_args.iter().map(|x| x.name));
+                    result.extend(inst_args.iter().map(|x| (x.name, IdentifierInfo::default())));
                    result
                };
                let mut calls: HashMap<CodeLocation, CallId> = HashMap::new();
@ -1930,23 +2123,43 @@ impl TopLevelComposer {
                else {
                    unreachable!("must be function def ast")
                };
-                    if !decorator_list.is_empty()
+
-                        && matches!(&decorator_list[0].node,
+                if !decorator_list.is_empty() {
-                            ast::ExprKind::Name{ id, .. } if id == &"extern".into())
+                    if matches!(&decorator_list[0].node, ExprKind::Name { id, .. } if id == &"extern".into())
                    {
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }
                    if !decorator_list.is_empty()
                        && matches!(&decorator_list[0].node,
                            ast::ExprKind::Name{ id, .. } if id == &"rpc".into())
                    {
                        let TopLevelDef::Function { instance_to_symbol, .. } = &mut *def.write()
                        else {
                            unreachable!()
                        };
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }
-                    let fun_body = body
+                    if matches!(&decorator_list[0].node, ExprKind::Name { id, .. } if id == &"rpc".into())
-                        .into_iter()
+                    {
                        let TopLevelDef::Function { instance_to_symbol, .. } = &mut *def.write()
                        else {
                            unreachable!()
                        };
                        instance_to_symbol.insert(String::new(), simple_name.to_string());
                        continue;
                    }
                    if let ExprKind::Call { func, .. } = &decorator_list[0].node {
                        if matches!(&func.node, ExprKind::Name { id, .. } if id == &"rpc".into()) {
                            let TopLevelDef::Function { instance_to_symbol, .. } =
                                &mut *def.write()
                            else {
                                unreachable!()
                            };
                            instance_to_symbol.insert(String::new(), simple_name.to_string());
                            continue;
                        }
                    }
                }
                let fun_body =
                    body.into_iter()
                        .map(|b| inferencer.fold_stmt(b))
                        .collect::<Result<Vec<_>, _>>()?;
@ -2016,6 +2229,9 @@ impl TopLevelComposer {
                    )]));
                }
                let TopLevelDef::Function { instance_to_stmt, .. } = &mut *def.write() else {
                    unreachable!()
                };
                instance_to_stmt.insert(
                    get_subst_key(
                        unifier,
@ -2031,10 +2247,10 @@ impl TopLevelComposer {
                    },
                );
            }
            }
            Ok(())
        };
        for (id, (def, ast)) in self.definition_ast_list.iter().enumerate().skip(self.builtin_num) {
            if ast.is_none() {
                continue;
@ -2048,4 +2264,59 @@ impl TopLevelComposer {
        }
        Ok(())
    }
    /// Step 6. Analyze and populate the types of global variables.
    fn analyze_top_level_variables(&mut self) -> Result<(), HashSet<String>> {
        let def_list = &self.definition_ast_list;
        let temp_def_list = self.extract_def_list();
        let unifier = &mut self.unifier;
        let primitives_store = &self.primitives_ty;
        let mut analyze = |variable_def: &Arc<RwLock<TopLevelDef>>| -> Result<_, HashSet<String>> {
            let TopLevelDef::Variable { ty: dummy_ty, ty_decl, resolver, loc, .. } =
                &*variable_def.read()
            else {
                // not top level variable def, skip
                return Ok(());
            };
            let resolver = &**resolver.as_ref().unwrap();
            if let Some(ty_decl) = ty_decl {
                let ty_annotation = parse_ast_to_type_annotation_kinds(
                    resolver,
                    &temp_def_list,
                    unifier,
                    primitives_store,
                    ty_decl,
                    HashMap::new(),
                )?;
                let ty_from_ty_annotation = get_type_from_type_annotation_kinds(
                    &temp_def_list,
                    unifier,
                    primitives_store,
                    &ty_annotation,
                    &mut None,
                )?;
                unifier.unify(*dummy_ty, ty_from_ty_annotation).map_err(|e| {
                    HashSet::from([e.at(Some(loc.unwrap())).to_display(unifier).to_string()])
                })?;
            }
            Ok(())
        };
        let mut errors = HashSet::new();
        for (variable_def, _) in def_list.iter().skip(self.builtin_num) {
            if let Err(e) = analyze(variable_def) {
                errors.extend(e);
            }
        }
        if !errors.is_empty() {
            return Err(errors);
        }
        Ok(())
    }
 }
--- a/nac3core/src/toplevel/helper.rs
+++ b/nac3core/src/toplevel/helper.rs
@ -1,13 +1,15 @@
 use std::convert::TryInto;
 use crate::symbol_resolver::SymbolValue;
 use crate::toplevel::numpy::unpack_ndarray_var_tys;
 use crate::typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap};
 use nac3parser::ast::{Constant, Location};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
-use super::*;
+use nac3parser::ast::{Constant, ExprKind, Location};
 use super::{numpy::unpack_ndarray_var_tys, *};
 use crate::{
    symbol_resolver::SymbolValue,
    typecheck::typedef::{into_var_map, iter_type_vars, Mapping, TypeVarId, VarMap},
 };
 /// All primitive types and functions in nac3core.
 #[derive(Clone, Copy, Debug, EnumIter, PartialEq, Eq)]
@ -27,17 +29,22 @@ pub enum PrimDef {
    List,
    NDArray,
-    // Member Functions
+    // Option methods
-    OptionIsSome,
+    FunOptionIsSome,
-    OptionIsNone,
+    FunOptionIsNone,
-    OptionUnwrap,
+    FunOptionUnwrap,
-    NDArrayCopy,
+
-    NDArrayFill,
+    // Option-related functions
-    FunInt32,
+    FunSome,
-    FunInt64,
+
-    FunUInt32,
+    // NDArray methods
-    FunUInt64,
+    FunNDArrayCopy,
-    FunFloat,
+    FunNDArrayFill,
    // Range methods
    FunRangeInit,
    // NumPy factory functions
    FunNpNDArray,
    FunNpEmpty,
    FunNpZeros,
@ -46,26 +53,17 @@ pub enum PrimDef {
    FunNpArray,
    FunNpEye,
    FunNpIdentity,
-    FunRound,
+
-    FunRound64,
+    // Miscellaneous NumPy & SciPy functions
    FunNpRound,
    FunRangeInit,
    FunStr,
    FunBool,
    FunFloor,
    FunFloor64,
    FunNpFloor,
    FunCeil,
    FunCeil64,
    FunNpCeil,
    FunLen,
    FunMin,
    FunNpMin,
    FunNpMinimum,
-    FunMax,
+    FunNpArgmin,
    FunNpMax,
    FunNpMaximum,
-    FunAbs,
+    FunNpArgmax,
    FunNpIsNan,
    FunNpIsInf,
    FunNpSin,
@ -103,15 +101,46 @@ pub enum PrimDef {
    FunNpLdExp,
    FunNpHypot,
    FunNpNextAfter,
    FunNpTranspose,
    FunNpReshape,
-    // Top-Level Functions
+    // Linalg functions
-    FunSome,
+    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 {
@ -153,15 +182,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 {
@ -169,29 +200,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::List => class("list"),
+
-            PrimDef::NDArray => class("ndarray"),
+            // Option methods
-            PrimDef::NDArrayCopy => fun("ndarray.copy", Some("copy")),
+            PrimDef::FunOptionIsSome => fun("Option.is_some", Some("is_some")),
-            PrimDef::NDArrayFill => fun("ndarray.fill", Some("fill")),
+            PrimDef::FunOptionIsNone => fun("Option.is_none", Some("is_none")),
-            PrimDef::FunInt32 => fun("int32", None),
+            PrimDef::FunOptionUnwrap => fun("Option.unwrap", Some("unwrap")),
-            PrimDef::FunInt64 => fun("int64", None),
+
-            PrimDef::FunUInt32 => fun("uint32", None),
+            // Option-related functions
-            PrimDef::FunUInt64 => fun("uint64", None),
+            PrimDef::FunSome => fun("Some", None),
-            PrimDef::FunFloat => fun("float", 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),
@ -200,26 +239,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::FunRangeInit => fun("range.__init__", Some("__init__")),
            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),
@ -257,7 +287,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::FunNpReshape => fun("np_reshape", 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),
        }
    }
 }
@ -326,6 +389,9 @@ impl TopLevelDef {
                    r
                }
            ),
            TopLevelDef::Variable { name, ty, .. } => {
                format!("Variable {{ name: {name:?}, ty: {:?} }}", unifier.stringify(*ty),)
            }
        }
    }
 }
@ -408,9 +474,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<_, _>>(),
@ -444,6 +510,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]),
@ -451,8 +518,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]),
        });
@ -526,6 +593,18 @@ impl TopLevelComposer {
        }
    }
    #[must_use]
    pub fn make_top_level_variable_def(
        name: String,
        simple_name: StrRef,
        ty: Type,
        ty_decl: Option<Expr>,
        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
        loc: Option<Location>,
    ) -> TopLevelDef {
        TopLevelDef::Variable { name, simple_name, ty, ty_decl, resolver, loc }
    }
    #[must_use]
    pub fn make_class_method_name(mut class_name: String, method_name: &str) -> String {
        class_name.push('.');
@ -671,7 +750,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 {
@ -707,30 +795,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!()
--- a/nac3core/src/toplevel/mod.rs
+++ b/nac3core/src/toplevel/mod.rs
@ -6,36 +6,36 @@ use std::{
    sync::Arc,
 };
 use super::codegen::CodeGenContext;
 use super::typecheck::type_inferencer::PrimitiveStore;
 use super::typecheck::typedef::{
    FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, Unifier, VarMap,
 };
 use crate::{
    codegen::CodeGenerator,
    symbol_resolver::{SymbolResolver, ValueEnum},
    typecheck::{
        type_inferencer::CodeLocation,
        typedef::{CallId, TypeVarId},
    },
 };
 use inkwell::values::BasicValueEnum;
 use itertools::Itertools;
 use nac3parser::ast::{self, Location, Stmt, StrRef};
 use parking_lot::RwLock;
-#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
+use nac3parser::ast::{self, Expr, Location, Stmt, StrRef};
-pub struct DefinitionId(pub usize);
+
 use crate::{
    codegen::{CodeGenContext, CodeGenerator},
    symbol_resolver::{SymbolResolver, ValueEnum},
    typecheck::{
        type_inferencer::{CodeLocation, PrimitiveStore},
        typedef::{
            CallId, FunSignature, FuncArg, SharedUnifier, Type, TypeEnum, TypeVarId, Unifier,
            VarMap,
        },
    },
 };
 use composer::*;
 use type_annotation::*;
 pub mod builtins;
 pub mod composer;
 pub mod helper;
 pub mod numpy;
 pub mod type_annotation;
 use composer::*;
 use type_annotation::*;
 #[cfg(test)]
 mod test;
 pub mod type_annotation;
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash, Debug)]
 pub struct DefinitionId(pub usize);
 type GenCallCallback = dyn for<'ctx, 'a> Fn(
        &mut CodeGenContext<'ctx, 'a>,
@ -148,6 +148,25 @@ pub enum TopLevelDef {
        /// Definition location.
        loc: Option<Location>,
    },
    Variable {
        /// Qualified name of the global variable, should be unique globally.
        name: String,
        /// Simple name, the same as in method/function definition.
        simple_name: StrRef,
        /// Type of the global variable.
        ty: Type,
        /// The declared type of the global variable, or [`None`] if no type annotation is provided.
        ty_decl: Option<Expr>,
        /// Symbol resolver of the module defined the class.
        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
        /// Definition location.
        loc: Option<Location>,
    },
 }
 pub struct TopLevelContext {
--- a/nac3core/src/toplevel/numpy.rs
+++ b/nac3core/src/toplevel/numpy.rs
@ -1,11 +1,10 @@
-use crate::{
+use itertools::Itertools;
-    toplevel::helper::PrimDef,
+
-    typecheck::{
+use super::helper::PrimDef;
 use crate::typecheck::{
    type_inferencer::PrimitiveStore,
    typedef::{Type, TypeEnum, TypeVarId, Unifier, VarMap},
    },
 };
 use itertools::Itertools;
 /// Creates a `ndarray` [`Type`] with the given type arguments.
 ///
--- 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(245)]\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[typevar234]\", \"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: [\"typevar234\"]\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(247)]\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(252)]\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[typevar233, typevar234]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar233\", \"typevar234\"]\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(253)]\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(261)]\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,21 +1,23 @@
-use super::*;
+use std::{collections::HashMap, sync::Arc};
-use crate::toplevel::helper::PrimDef;
+
-use crate::typecheck::typedef::into_var_map;
+use indoc::indoc;
 use parking_lot::Mutex;
 use test_case::test_case;
 use nac3parser::{
    ast::{fold::Fold, FileName},
    parser::parse_program,
 };
 use super::{helper::PrimDef, DefinitionId, *};
 use crate::{
    codegen::CodeGenContext,
    symbol_resolver::{SymbolResolver, ValueEnum},
    toplevel::DefinitionId,
    typecheck::{
        type_inferencer::PrimitiveStore,
-        typedef::{Type, Unifier},
+        typedef::{into_var_map, Type, Unifier},
    },
 };
 use indoc::indoc;
 use nac3parser::ast::FileName;
 use nac3parser::{ast::fold::Fold, parser::parse_program};
 use parking_lot::Mutex;
 use std::{collections::HashMap, sync::Arc};
 use test_case::test_case;
 struct ResolverInternal {
    id_to_type: Mutex<HashMap<StrRef, Type>>,
@ -62,6 +64,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -117,7 +120,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();
@ -137,7 +141,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();
@ -171,7 +176,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(),
@ -519,7 +525,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![
@ -696,7 +703,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![
--- a/nac3core/src/toplevel/type_annotation.rs
+++ b/nac3core/src/toplevel/type_annotation.rs
@ -1,9 +1,13 @@
-use super::*;
+use strum::IntoEnumIterator;
-use crate::symbol_resolver::SymbolValue;
+
 use crate::toplevel::helper::PrimDef;
 use crate::typecheck::typedef::VarMap;
 use nac3parser::ast::Constant;
 use super::{
    helper::{PrimDef, PrimDefDetails},
    *,
 };
 use crate::{symbol_resolver::SymbolValue, typecheck::typedef::VarMap};
 #[derive(Clone, Debug)]
 pub enum TypeAnnotation {
    Primitive(Type),
@ -357,6 +361,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>> {
@ -379,10 +384,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
@ -424,12 +462,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()
                                    }
                                };
@ -468,11 +509,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),
@ -490,6 +536,7 @@ 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,
            )?;
@ -499,10 +546,16 @@ pub fn get_type_from_type_annotation_kinds(
            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 }))
        }
    }
 }
--- a/nac3core/src/typecheck/function_check.rs
+++ b/nac3core/src/typecheck/function_check.rs
@ -1,13 +1,19 @@
-use crate::toplevel::helper::PrimDef;
+use std::{
    collections::{HashMap, HashSet},
    iter::once,
 };
 use super::type_inferencer::Inferencer;
 use super::typedef::{Type, TypeEnum};
 use nac3parser::ast::{
    self, Constant, Expr, ExprKind,
    Operator::{LShift, RShift},
    Stmt, StmtKind, StrRef,
 };
-use std::{collections::HashSet, iter::once};
+
 use super::{
    type_inferencer::{DeclarationSource, IdentifierInfo, Inferencer},
    typedef::{Type, TypeEnum},
 };
 use crate::toplevel::helper::PrimDef;
 impl<'a> Inferencer<'a> {
    fn should_have_value(&mut self, expr: &Expr<Option<Type>>) -> Result<(), HashSet<String>> {
@ -21,26 +27,45 @@ impl<'a> Inferencer<'a> {
    fn check_pattern(
        &mut self,
        pattern: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        match &pattern.node {
            ExprKind::Name { id, .. } if id == &"none".into() => {
                Err(HashSet::from([format!("cannot assign to a `none` (at {})", pattern.location)]))
            }
            ExprKind::Name { id, .. } => {
-                if !defined_identifiers.contains(id) {
+                // If `id` refers to a declared symbol, reject this assignment if it is used in the
-                    defined_identifiers.insert(*id);
+                // context of an (implicit) global variable
                if let Some(id_info) = defined_identifiers.get(id) {
                    if matches!(
                        id_info.source,
                        DeclarationSource::Global { is_explicit: Some(false) }
                    ) {
                        return Err(HashSet::from([format!(
                            "cannot access local variable '{id}' before it is declared (at {})",
                            pattern.location
                        )]));
                    }
                }
                if !defined_identifiers.contains_key(id) {
                    defined_identifiers.insert(*id, IdentifierInfo::default());
                }
                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)?;
@ -64,7 +89,7 @@ impl<'a> Inferencer<'a> {
    fn check_expr(
        &mut self,
        expr: &Expr<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<(), HashSet<String>> {
        // there are some cases where the custom field is None
        if let Some(ty) = &expr.custom {
@ -85,7 +110,7 @@ impl<'a> Inferencer<'a> {
                    return Ok(());
                }
                self.should_have_value(expr)?;
-                if !defined_identifiers.contains(id) {
+                if !defined_identifiers.contains_key(id) {
                    match self.function_data.resolver.get_symbol_type(
                        self.unifier,
                        &self.top_level.definitions.read(),
@ -93,7 +118,22 @@ impl<'a> Inferencer<'a> {
                        *id,
                    ) {
                        Ok(_) => {
-                            self.defined_identifiers.insert(*id);
+                            let is_global = self.is_id_global(*id);
                            defined_identifiers.insert(
                                *id,
                                IdentifierInfo {
                                    source: match is_global {
                                        Some(true) => {
                                            DeclarationSource::Global { is_explicit: Some(false) }
                                        }
                                        Some(false) => {
                                            DeclarationSource::Global { is_explicit: None }
                                        }
                                        None => DeclarationSource::Local,
                                    },
                                },
                            );
                        }
                        Err(e) => {
                            return Err(HashSet::from([format!(
@ -166,9 +206,7 @@ impl<'a> Inferencer<'a> {
                let mut defined_identifiers = defined_identifiers.clone();
                for arg in &args.args {
                    // TODO: should we check the types here?
-                    if !defined_identifiers.contains(&arg.node.arg) {
+                    defined_identifiers.entry(arg.node.arg).or_default();
                        defined_identifiers.insert(arg.node.arg);
                    }
                }
                self.check_expr(body, &mut defined_identifiers)?;
            }
@ -207,6 +245,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,
@ -218,16 +259,17 @@ 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(
        &mut self,
        stmt: &Stmt<Option<Type>>,
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        match &stmt.node {
            StmtKind::For { target, iter, body, orelse, .. } => {
@ -253,9 +295,11 @@ impl<'a> Inferencer<'a> {
                let body_returned = self.check_block(body, &mut body_identifiers)?;
                let orelse_returned = self.check_block(orelse, &mut orelse_identifiers)?;
-                for ident in &body_identifiers {
+                for ident in body_identifiers.keys() {
-                    if !defined_identifiers.contains(ident) && orelse_identifiers.contains(ident) {
+                    if !defined_identifiers.contains_key(ident)
-                        defined_identifiers.insert(*ident);
+                        && orelse_identifiers.contains_key(ident)
                    {
                        defined_identifiers.insert(*ident, IdentifierInfo::default());
                    }
                }
                Ok(body_returned && orelse_returned)
@ -286,7 +330,7 @@ impl<'a> Inferencer<'a> {
                    let mut defined_identifiers = defined_identifiers.clone();
                    let ast::ExcepthandlerKind::ExceptHandler { name, body, .. } = &handler.node;
                    if let Some(name) = name {
-                        defined_identifiers.insert(*name);
+                        defined_identifiers.insert(*name, IdentifierInfo::default());
                    }
                    self.check_block(body, &mut defined_identifiers)?;
                }
@ -350,6 +394,44 @@ impl<'a> Inferencer<'a> {
                }
                Ok(true)
            }
            StmtKind::Global { names, .. } => {
                for id in names {
                    if let Some(id_info) = defined_identifiers.get(id) {
                        if id_info.source == DeclarationSource::Local {
                            return Err(HashSet::from([format!(
                                "name '{id}' is referenced prior to global declaration at {}",
                                stmt.location,
                            )]));
                        }
                        continue;
                    }
                    match self.function_data.resolver.get_symbol_type(
                        self.unifier,
                        &self.top_level.definitions.read(),
                        self.primitives,
                        *id,
                    ) {
                        Ok(_) => {
                            defined_identifiers.insert(
                                *id,
                                IdentifierInfo {
                                    source: DeclarationSource::Global { is_explicit: Some(true) },
                                },
                            );
                        }
                        Err(e) => {
                            return Err(HashSet::from([format!(
                                "type error at identifier `{}` ({}) at {}",
                                id, e, stmt.location
                            )]))
                        }
                    }
                }
                Ok(false)
            }
            // break, raise, etc.
            _ => Ok(false),
        }
@ -358,7 +440,7 @@ impl<'a> Inferencer<'a> {
    pub fn check_block(
        &mut self,
        block: &[Stmt<Option<Type>>],
-        defined_identifiers: &mut HashSet<StrRef>,
+        defined_identifiers: &mut HashMap<StrRef, IdentifierInfo>,
    ) -> Result<bool, HashSet<String>> {
        let mut ret = false;
        for stmt in block {
--- a/nac3core/src/typecheck/magic_methods.rs
+++ b/nac3core/src/typecheck/magic_methods.rs
@ -1,17 +1,21 @@
-use crate::symbol_resolver::SymbolValue;
+use std::{cmp::max, collections::HashMap, rc::Rc};
-use crate::toplevel::helper::PrimDef;
+
-use crate::toplevel::numpy::{make_ndarray_ty, unpack_ndarray_var_tys};
+use itertools::{iproduct, Itertools};
-use crate::typecheck::{
+use strum::IntoEnumIterator;
 use nac3parser::ast::{Cmpop, Operator, StrRef, Unaryop};
 use super::{
    type_inferencer::*,
    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
 };
-use itertools::{iproduct, Itertools};
+use crate::{
-use nac3parser::ast::StrRef;
+    symbol_resolver::SymbolValue,
-use nac3parser::ast::{Cmpop, Operator, Unaryop};
+    toplevel::{
-use std::cmp::max;
+        helper::PrimDef,
-use std::collections::HashMap;
+        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
-use std::rc::Rc;
+    },
-use strum::IntoEnumIterator;
+};
 /// The variant of a binary operator.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@ -197,6 +201,7 @@ pub fn impl_binop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
                            is_vararg: false,
                        }],
                    })),
                    false,
@ -261,6 +266,7 @@ pub fn impl_cmpop(
                            ty: other_ty,
                            default_value: None,
                            name: "other".into(),
                            is_vararg: false,
                        }],
                    })),
                    false,
@ -518,6 +524,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, .. } => {
@ -678,6 +701,7 @@ 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,
        ..
@ -723,6 +747,9 @@ 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]);
--- a/nac3core/src/typecheck/type_error.rs
+++ b/nac3core/src/typecheck/type_error.rs
@ -1,14 +1,13 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt::Display};
 use std::fmt::Display;
-use crate::typecheck::{magic_methods::HasOpInfo, typedef::TypeEnum};
+use itertools::Itertools;
 use nac3parser::ast::{Cmpop, Location, StrRef};
 use super::{
-    magic_methods::Binop,
+    magic_methods::{Binop, HasOpInfo},
-    typedef::{RecordKey, Type, Unifier},
+    typedef::{RecordKey, Type, TypeEnum, Unifier},
 };
 use itertools::Itertools;
 use nac3parser::ast::{Cmpop, Location, StrRef};
 #[derive(Debug, Clone)]
 pub enum TypeErrorKind {
@ -183,9 +182,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}")
--- 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
@ -1,18 +1,20 @@
-use super::super::{magic_methods::with_fields, typedef::*};
+use std::iter::zip;
-use super::*;
+
 use crate::{
    codegen::CodeGenContext,
    symbol_resolver::ValueEnum,
    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
 };
 use indexmap::IndexMap;
 use indoc::indoc;
 use nac3parser::ast::FileName;
 use nac3parser::parser::parse_program;
 use parking_lot::RwLock;
 use std::iter::zip;
 use test_case::test_case;
 use nac3parser::{ast::FileName, parser::parse_program};
 use super::*;
 use crate::{
    codegen::{CodeGenContext, CodeGenerator},
    symbol_resolver::ValueEnum,
    toplevel::{helper::PrimDef, DefinitionId, TopLevelDef},
    typecheck::{magic_methods::with_fields, typedef::*},
 };
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
    id_to_def: HashMap<StrRef, DefinitionId>,
@ -41,6 +43,7 @@ impl SymbolResolver for Resolver {
        &self,
        _: StrRef,
        _: &mut CodeGenContext<'ctx, '_>,
        _: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
        unimplemented!()
    }
@ -83,7 +86,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(),
            }));
@ -224,7 +232,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(),
            }));
@ -507,7 +520,7 @@ impl TestEnvironment {
            primitives: &mut self.primitives,
            virtual_checks: &mut self.virtual_checks,
            calls: &mut self.calls,
-            defined_identifiers: HashSet::default(),
+            defined_identifiers: HashMap::default(),
            in_handler: false,
        }
    }
@ -583,8 +596,9 @@ fn test_basic(source: &str, mapping: &HashMap<&str, &str>, virtuals: &[(&str, &s
    println!("source:\n{source}");
    let mut env = TestEnvironment::new();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
+    let mut defined_identifiers: HashMap<_, _> =
-    defined_identifiers.insert("virtual".into());
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
@ -729,8 +743,9 @@ fn test_primitive_magic_methods(source: &str, mapping: &HashMap<&str, &str>) {
    println!("source:\n{source}");
    let mut env = TestEnvironment::basic_test_env();
    let id_to_name = std::mem::take(&mut env.id_to_name);
-    let mut defined_identifiers: HashSet<_> = env.identifier_mapping.keys().copied().collect();
+    let mut defined_identifiers: HashMap<_, _> =
-    defined_identifiers.insert("virtual".into());
+        env.identifier_mapping.keys().copied().map(|id| (id, IdentifierInfo::default())).collect();
    defined_identifiers.insert("virtual".into(), IdentifierInfo::default());
    let mut inferencer = env.get_inferencer();
    inferencer.defined_identifiers.clone_from(&defined_identifiers);
    let statements = parse_program(source, FileName::default()).unwrap();
--- a/nac3core/src/typecheck/typedef/mod.rs
+++ b/nac3core/src/typecheck/typedef/mod.rs
@ -1,23 +1,28 @@
 use std::{
    borrow::Cow,
    cell::RefCell,
    collections::{HashMap, HashSet},
    fmt::{self, Display},
    iter::{repeat, zip},
    rc::Rc,
    sync::{Arc, Mutex},
 };
 use indexmap::IndexMap;
-use itertools::Itertools;
+use itertools::{repeat_n, 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::{Cmpop, Location, StrRef, Unaryop};
-use super::magic_methods::Binop;
+use super::{
-use super::type_error::{TypeError, TypeErrorKind};
+    magic_methods::{Binop, HasOpInfo, OpInfo},
-use super::unification_table::{UnificationKey, UnificationTable};
+    type_error::{TypeError, TypeErrorKind},
-use crate::symbol_resolver::SymbolValue;
+    type_inferencer::PrimitiveStore,
-use crate::toplevel::helper::PrimDef;
+    unification_table::{UnificationKey, UnificationTable},
-use crate::toplevel::{DefinitionId, TopLevelContext, TopLevelDef};
+};
-use crate::typecheck::magic_methods::OpInfo;
+use crate::{
-use crate::typecheck::type_inferencer::PrimitiveStore;
+    symbol_resolver::SymbolValue,
    toplevel::{helper::PrimDef, DefinitionId, TopLevelContext, TopLevelDef},
 };
 #[cfg(test)]
 mod test;
@ -115,6 +120,7 @@ pub struct FuncArg {
    pub name: StrRef,
    pub ty: Type,
    pub default_value: Option<SymbolValue>,
    pub is_vararg: bool,
 }
 impl FuncArg {
@ -233,6 +239,12 @@ pub enum TypeEnum {
    TTuple {
        /// The types of elements present in this tuple.
        ty: Vec<Type>,
        /// Whether this tuple is used in a vararg context.
        ///
        /// If `true`, `ty` must only contain one type, and the tuple is assumed to contain any
        /// number of `ty`-typed values.
        is_vararg_ctx: bool,
    },
    /// An object type.
@ -527,7 +539,7 @@ impl Unifier {
            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]))
@ -537,7 +549,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(),
                    )
                }
            }
@ -581,7 +598,7 @@ impl Unifier {
            TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
            TCall { .. } => false,
            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))
            }
@ -649,6 +666,7 @@ impl Unifier {
        // Get details about the function signature/parameters.
        let num_params = signature.args.len();
        let is_vararg = signature.args.iter().any(|arg| arg.is_vararg);
        // Force the type vars in `b` and `signature' to be up-to-date.
        let b = self.instantiate_fun(b, signature);
@ -659,8 +677,8 @@ impl Unifier {
        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 the behavior `unify_call()`
+        // and depending on what `call_info` is, we might change how `unify_call()` behaves
-        // in hopes to improve user error messages when type checking fails.
+        // 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`.
@ -737,7 +755,7 @@ impl Unifier {
                };
                // Check for "too many arguments"
-                if num_params < posargs.len() {
+                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;
@ -770,6 +788,19 @@ impl Unifier {
                    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".
@ -959,7 +990,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 {
@ -980,8 +1014,18 @@ 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,
                            ];
                            if !tuple_fns.into_iter().any(|op| s.to_string() == op) {
                                return Err(TypeError::new(
                                    TypeErrorKind::NoSuchField(*k, b),
                                    v.loc,
                                ));
                            }
                        }
                    }
                }
@ -1056,15 +1100,47 @@ 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);
            }
            (TVar { fields: Some(map), range, .. }, TObj { obj_id, fields, params }) => {
@ -1307,11 +1383,23 @@ 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::TVirtual { ty } => {
                format!(
                    "virtual[{}]",
@ -1335,17 +1423,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)
                            )
                        }
@ -1431,7 +1523,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) {
@ -1439,7 +1531,10 @@ 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
                }
@ -1599,16 +1694,37 @@ 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
                    })
                }
            }
            // TODO(Derppening): #444
--- a/nac3core/src/typecheck/typedef/test.rs
+++ b/nac3core/src/typecheck/typedef/test.rs
@ -1,10 +1,12 @@
-use super::super::magic_methods::with_fields;
+use std::collections::HashMap;
-use super::*;
+
 use indoc::indoc;
 use itertools::Itertools;
 use std::collections::HashMap;
 use test_case::test_case;
 use super::*;
 use crate::typecheck::magic_methods::with_fields;
 impl Unifier {
    /// Check whether two types are equal.
    fn eq(&mut self, a: Type, b: Type) -> bool {
@ -28,7 +30,10 @@ 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))
            }
@ -178,7 +183,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..])
            }
            "Record" => {
                let mut s = &typ[end..];
@ -608,7 +613,7 @@ fn test_instantiation() {
    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)
--- 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/nac3ld/src/lib.rs
+++ b/nac3ld/src/lib.rs
@ -21,13 +21,12 @@
    clippy::wildcard_imports
 )]
 use std::{collections::HashMap, mem, ptr, slice, str};
 use byteorder::{ByteOrder, LittleEndian};
 use dwarf::*;
 use elf::*;
 use std::collections::HashMap;
 use std::{mem, ptr, slice, str};
 extern crate byteorder;
 use byteorder::{ByteOrder, LittleEndian};
 mod dwarf;
 mod elf;
--- a/nac3parser/Cargo.toml
+++ b/nac3parser/Cargo.toml
@ -8,15 +8,15 @@ license = "MIT"
 edition = "2021"
 [build-dependencies]
-lalrpop = "0.20"
+lalrpop = "0.22"
 [dependencies]
 nac3ast = { path = "../nac3ast" }
-lalrpop-util = "0.20"
+lalrpop-util = "0.22"
 log = "0.4"
 unic-emoji-char = "0.9"
 unic-ucd-ident  = "0.9"
-unicode_names2 = "1.2"
+unicode_names2 = "1.3"
 phf = { version = "0.11", features = ["macros"] }
 ahash = "0.8"
--- a/nac3parser/src/config_comment_helper.rs
+++ b/nac3parser/src/config_comment_helper.rs
@ -1,8 +1,10 @@
-use crate::ast::Ident;
+use crate::{
-use crate::ast::Location;
+    ast::{Ident, Location},
-use crate::error::*;
+    error::*,
-use crate::token::Tok;
+    token::Tok,
 };
 use lalrpop_util::ParseError;
 use nac3ast::*;
 pub fn make_config_comment(
--- a/nac3parser/src/error.rs
+++ b/nac3parser/src/error.rs
@ -1,13 +1,12 @@
 //! Define internal parse error types
 //! The goal is to provide a matching and a safe error API, maksing errors from LALR
 use lalrpop_util::ParseError as LalrpopError;
 use crate::ast::Location;
 use crate::token::Tok;
 use std::error::Error;
 use std::fmt;
 use lalrpop_util::ParseError as LalrpopError;
 use crate::{ast::Location, token::Tok};
 /// Represents an error during lexical scanning.
 #[derive(Debug, PartialEq)]
 pub struct LexicalError {
--- a/nac3parser/src/fstring.rs
+++ b/nac3parser/src/fstring.rs
@ -1,12 +1,11 @@
-use std::iter;
+use std::{iter, mem, str};
 use std::mem;
 use std::str;
 use crate::ast::{Constant, ConversionFlag, Expr, ExprKind, Location};
 use crate::error::{FStringError, FStringErrorType, ParseError};
 use crate::parser::parse_expression;
 use self::FStringErrorType::*;
 use crate::{
    ast::{Constant, ConversionFlag, Expr, ExprKind, Location},
    error::{FStringError, FStringErrorType, ParseError},
    parser::parse_expression,
 };
 struct FStringParser<'a> {
    chars: iter::Peekable<str::Chars<'a>>,
--- a/nac3parser/src/function.rs
+++ b/nac3parser/src/function.rs
@ -1,8 +1,11 @@
 use ahash::RandomState;
 use std::collections::HashSet;
-use crate::ast;
+use ahash::RandomState;
-use crate::error::{LexicalError, LexicalErrorType};
+
 use crate::{
    ast,
    error::{LexicalError, LexicalErrorType},
 };
 pub struct ArgumentList {
    pub args: Vec<ast::Expr>,
--- a/nac3parser/src/lexer.rs
+++ b/nac3parser/src/lexer.rs
@ -1,17 +1,17 @@
 //! This module takes care of lexing python source text.
 //!
 //! This means source code is translated into separate tokens.
 use std::{char, cmp::Ordering, num::IntErrorKind, str::FromStr};
 pub use super::token::Tok;
 use crate::ast::{FileName, Location};
 use crate::error::{LexicalError, LexicalErrorType};
 use std::char;
 use std::cmp::Ordering;
 use std::num::IntErrorKind;
 use std::str::FromStr;
 use unic_emoji_char::is_emoji_presentation;
 use unic_ucd_ident::{is_xid_continue, is_xid_start};
 pub use super::token::Tok;
 use crate::{
    ast::{FileName, Location},
    error::{LexicalError, LexicalErrorType},
 };
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 struct IndentationLevel {
    tabs: usize,
--- a/nac3parser/src/parser.rs
+++ b/nac3parser/src/parser.rs
@ -5,14 +5,16 @@
 //! parse a whole program, a single statement, or a single
 //! expression.
 use nac3ast::Location;
 use std::iter;
-use crate::ast::{self, FileName};
+use nac3ast::Location;
-use crate::error::ParseError;
+
 use crate::lexer;
 pub use crate::mode::Mode;
-use crate::python;
+use crate::{
    ast::{self, FileName},
    error::ParseError,
    lexer, python,
 };
 /*
 * Parse python code.
--- a/nac3parser/src/token.rs
+++ b/nac3parser/src/token.rs
@ -1,8 +1,9 @@
 //! Different token definitions.
 //! Loosely based on token.h from CPython source:
 use crate::ast;
 use std::fmt::{self, Write};
 use crate::ast;
 /// Python source code can be tokenized in a sequence of these tokens.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Tok {
--- 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;
 }
@ -64,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 {
@ -85,7 +83,7 @@ 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]);
    }
 }
@ -107,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
@ -167,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
@ -183,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
@ -215,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
@ -224,14 +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_linalg_det = np.linalg.det
    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/globals.py
+++ b/nac3standalone/demo/src/globals.py
@ -0,0 +1,31 @@
@extern
 def output_int32(x: int32):
    ...
@extern
 def output_int64(x: int64):
    ...
 X: int32 = 0
 Y = int64(1)
 def f():
    global X, Y
    X = 1
    Y = int64(2)
 def run() -> int32:
    global X, Y
    output_int32(X)
    output_int64(Y)
    f()
    output_int32(X)
    output_int64(Y)
    X = 0
    Y = int64(0)
    output_int32(X)
    output_int64(Y)
    return 0
--- 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/ndarray.py
+++ b/nac3standalone/demo/src/ndarray.py
@ -114,12 +114,22 @@ 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)
@ -867,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)
@ -910,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)
@ -1415,6 +1439,142 @@ def test_ndarray_nextafter_broadcast_rhs_scalar():
    output_ndarray_float_2(nextafter_x_zeros)
    output_ndarray_float_2(nextafter_x_ones)
 def test_ndarray_transpose():
    x: ndarray[float, 2] = np_array([[1., 2., 3.], [4., 5., 6.]])
    y = np_transpose(x)
    z = np_transpose(y)
    output_ndarray_float_2(x)
    output_ndarray_float_2(y)
 def test_ndarray_reshape():
    w: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
    x = np_reshape(w, (1, 2, 1, -1))
    y = np_reshape(x, [2, -1])
    z = np_reshape(y, 10)
    x1: ndarray[int32, 1] = np_array([1, 2, 3, 4])
    x2: ndarray[int32, 2] = np_reshape(x1, (2, 2))
    output_ndarray_float_1(w)
    output_ndarray_float_2(y)
    output_ndarray_float_1(z)
 def test_ndarray_dot():
    x1: ndarray[float, 1] = np_array([5.0, 1.0, 4.0, 2.0])
    y1: ndarray[float, 1] = np_array([5.0, 1.0, 6.0, 6.0])
    z1 = np_dot(x1, y1)
    x2: ndarray[int32, 1] = np_array([5, 1, 4, 2])
    y2: ndarray[int32, 1] = np_array([5, 1, 6, 6])
    z2 = np_dot(x2, y2)
    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)
 def run() -> int32:
    test_ndarray_ctor()
    test_ndarray_empty()
@ -1519,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()
@ -1591,5 +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_dot()
    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,5 +1,14 @@
 use std::{
    collections::{HashMap, HashSet},
    sync::Arc,
 };
 use parking_lot::{Mutex, RwLock};
 use nac3core::{
-    codegen::CodeGenContext,
+    codegen::{CodeGenContext, CodeGenerator},
    inkwell::{module::Linkage, values::BasicValue},
    nac3parser::ast::{self, StrRef},
    symbol_resolver::{SymbolResolver, SymbolValue, ValueEnum},
    toplevel::{DefinitionId, TopLevelDef},
    typecheck::{
@ -7,15 +16,10 @@ 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};
 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>>,
 }
@ -46,20 +50,51 @@ impl SymbolResolver for Resolver {
    fn get_symbol_type(
        &self,
-        _: &mut Unifier,
+        unifier: &mut Unifier,
        _: &[Arc<RwLock<TopLevelDef>>],
-        _: &PrimitiveStore,
+        primitives: &PrimitiveStore,
        str: StrRef,
    ) -> Result<Type, String> {
-        self.0.id_to_type.lock().get(&str).copied().ok_or(format!("cannot get type of {str}"))
+        self.0
            .id_to_type
            .lock()
            .get(&str)
            .copied()
            .or_else(|| {
                self.0
                    .module_globals
                    .lock()
                    .get(&str)
                    .cloned()
                    .map(|v| v.get_type(primitives, unifier))
            })
            .ok_or(format!("cannot get type of {str}"))
    }
    fn get_symbol_value<'ctx>(
        &self,
-        _: StrRef,
+        str: StrRef,
-        _: &mut CodeGenContext<'ctx, '_>,
+        ctx: &mut CodeGenContext<'ctx, '_>,
        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
-        unimplemented!()
+        self.0.module_globals.lock().get(&str).cloned().map(|v| {
            ctx.module
                .get_global(&str.to_string())
                .unwrap_or_else(|| {
                    let ty = v.get_type(&ctx.primitives, &mut ctx.unifier);
                    let init_val = ctx.gen_symbol_val(generator, &v, ty);
                    let llvm_ty = init_val.get_type();
                    let global = ctx.module.add_global(llvm_ty, None, &str.to_string());
                    global.set_linkage(Linkage::LinkOnceAny);
                    global.set_initializer(&init_val);
                    global
                })
                .as_basic_value_enum()
                .into()
        })
    }
    fn get_identifier_def(&self, id: StrRef) -> Result<DefinitionId, HashSet<String>> {
--- a/nac3standalone/src/main.rs
+++ b/nac3standalone/src/main.rs
@ -8,21 +8,30 @@
 #![warn(clippy::pedantic)]
 #![allow(clippy::too_many_lines, clippy::wildcard_imports)]
-use clap::Parser;
+use std::{
-use inkwell::{
+    collections::{HashMap, HashSet},
-    memory_buffer::MemoryBuffer, passes::PassBuilderOptions, support::is_multithreaded, targets::*,
+    fs,
-    OptimizationLevel,
+    num::NonZeroUsize,
    path::Path,
    sync::Arc,
 };
 use clap::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,
        CodeGenTargetMachineOptions, CodeGenTask, DefaultCodeGenerator, WithCall, WorkerRegistry,
    },
    inkwell::{
        memory_buffer::MemoryBuffer, module::Linkage, passes::PassBuilderOptions,
        support::is_multithreaded, targets::*, OptimizationLevel,
    },
    nac3parser::{
        ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
        parser,
    },
    symbol_resolver::SymbolResolver,
    toplevel::{
        composer::{ComposerConfig, TopLevelComposer},
@ -35,13 +44,10 @@ use nac3core::{
        typedef::{FunSignature, Type, Unifier, VarMap},
    },
 };
-use nac3parser::{
+
-    ast::{Constant, Expr, ExprKind, StmtKind, StrRef},
+use basic_symbol_resolver::*;
    parser,
 };
 mod basic_symbol_resolver;
 use basic_symbol_resolver::*;
 /// Command-line argument parser definition.
 #[derive(Parser)]
@ -113,7 +119,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 +160,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)
@ -167,46 +175,49 @@ fn handle_typevar_definition(
 fn handle_assignment_pattern(
    targets: &[Expr],
    value: &Expr,
-    resolver: &(dyn SymbolResolver + Send + Sync),
+    resolver: Arc<dyn SymbolResolver + Send + Sync>,
    internal_resolver: &ResolverInternal,
-    def_list: &[Arc<RwLock<TopLevelDef>>],
+    composer: &mut TopLevelComposer,
    unifier: &mut Unifier,
    primitives: &PrimitiveStore,
 ) -> Result<(), String> {
    if targets.len() == 1 {
-        match &targets[0].node {
+        let target = &targets[0];
        match &target.node {
            ExprKind::Name { id, .. } => {
                let def_list = composer.extract_def_list();
                let unifier = &mut composer.unifier;
                let primitives = &composer.primitives_ty;
                if let Ok(var) =
-                    handle_typevar_definition(value, resolver, def_list, unifier, primitives)
+                    handle_typevar_definition(value, &*resolver, &def_list, unifier, primitives)
                {
                    internal_resolver.add_id_type(*id, var);
                    Ok(())
-                } else if let Ok(val) = parse_parameter_default_value(value, resolver) {
+                } else if let Ok(val) = parse_parameter_default_value(value, &*resolver) {
                    internal_resolver.add_module_global(*id, val);
                    let (name, def_id, _) = composer
                        .register_top_level_var(
                            *id,
                            None,
                            Some(resolver.clone()),
                            "__main__",
                            target.location,
                        )
                        .unwrap();
                    internal_resolver.add_id_def(name, def_id);
                    Ok(())
                } else {
                    Err(format!("fails to evaluate this expression `{:?}` as a constant or generic parameter at {}",
-                        targets[0].node,
+                        target.node,
-                        targets[0].location,
+                        target.location,
                    ))
                }
            }
            ExprKind::List { elts, .. } | ExprKind::Tuple { elts, .. } => {
-                handle_assignment_pattern(
+                handle_assignment_pattern(elts, value, resolver, internal_resolver, composer)?;
                    elts,
                    value,
                    resolver,
                    internal_resolver,
                    def_list,
                    unifier,
                    primitives,
                )?;
                Ok(())
            }
-            _ => Err(format!(
+            _ => Err(format!("assignment to {target:?} is not supported at {}", target.location)),
                "assignment to {:?} is not supported at {}",
                targets[0], targets[0].location
            )),
        }
    } else {
        match &value.node {
@ -216,11 +227,9 @@ fn handle_assignment_pattern(
                        handle_assignment_pattern(
                            std::slice::from_ref(tar),
                            val,
-                            resolver,
+                            resolver.clone(),
                            internal_resolver,
-                            def_list,
+                            composer,
                            unifier,
                            primitives,
                        )?;
                    }
                    Ok(())
@ -238,9 +247,40 @@ fn handle_assignment_pattern(
    }
 }
-fn main() {
+fn handle_global_var(
-    const SIZE_T: u32 = usize::BITS;
+    target: &Expr,
    value: Option<&Expr>,
    resolver: &Arc<dyn SymbolResolver + Send + Sync>,
    internal_resolver: &ResolverInternal,
    composer: &mut TopLevelComposer,
 ) -> Result<(), String> {
    let ExprKind::Name { id, .. } = target.node else {
        return Err(format!(
            "global variable declaration must be an identifier (at {})",
            target.location,
        ));
    };
    let Some(value) = value else {
        return Err(format!("global variable `{id}` must be initialized in its definition"));
    };
    if let Ok(val) = parse_parameter_default_value(value, &**resolver) {
        internal_resolver.add_module_global(id, val);
        let (name, def_id, _) = composer
            .register_top_level_var(id, None, Some(resolver.clone()), "__main__", target.location)
            .unwrap();
        internal_resolver.add_id_def(name, def_id);
        Ok(())
    } else {
        Err(format!(
            "failed to evaluate this expression `{:?}` as a constant at {}",
            target.node, target.location,
        ))
    }
 }
 fn main() {
    let cli = CommandLineArgs::parse();
    let CommandLineArgs { file_name, threads, opt_level, emit_llvm, triple, mcpu, target_features } =
        cli;
@ -273,22 +313,36 @@ 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) => {
-            println!("Cannot open input file: {err}");
+            panic!("Cannot open input file: {err}");
            return;
        }
    };
-    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,27 +350,41 @@ 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 {
        match &stmt.node {
            StmtKind::Assign { targets, value, .. } => {
                let def_list = composer.extract_def_list();
                let unifier = &mut composer.unifier;
                let primitives = &composer.primitives_ty;
                if let Err(err) = handle_assignment_pattern(
                    targets,
                    value,
-                    resolver.as_ref(),
+                    resolver.clone(),
                    internal_resolver.as_ref(),
-                    &def_list,
+                    &mut composer,
                    unifier,
                    primitives,
                ) {
-                    eprintln!("{err}");
+                    panic!("{err}");
                    return;
                }
            }
            StmtKind::AnnAssign { target, value, .. } => {
                if let Err(err) = handle_global_var(
                    target,
                    value.as_ref().map(Box::as_ref),
                    &resolver,
                    internal_resolver.as_ref(),
                    &mut composer,
                ) {
                    panic!("{err}");
                }
            }
            // allow (and ignore) "from __future__ import annotations"
            StmtKind::ImportFrom { module, names, .. }
                if module == &Some("__future__".into())
@ -371,16 +439,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(),
@ -403,14 +462,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();
@ -430,25 +489,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);
@ -457,6 +509,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.8-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 = "1v8zkfcbf1ga2ndpd1j0dwv5s1rassxs2b5pjhcsmqwjcvczba1m";
+  sha256 = "0f9m76dx40iy794nfks0360gvjhdg6yngb2lyhwp4xd76rn5081m";
-  name = "mingw-w64-clang-x86_64-libunwind-18.1.8-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.8-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 = "0mfd8wrmgx12j5gf354j7pk1l3lg9ykxvq75xdk3jipsr6hbn846";
+  sha256 = "17savj9wys9my2ji7vyba7wwqkvzdjwnkb3k4858wxrjbzbfa6lk";
-  name = "mingw-w64-clang-x86_64-libc++-18.1.8-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libc++-18.1.8-2-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -43,9 +43,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libxml2-2.12.8-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 = "1imipb0dz4w6x4n9arn22imyzzcwdlf2cqxvn7irqq7w9by6fy0b";
+  sha256 = "0cjz2vj9yz6k5xj601cp0yk631rrr0z94ciamwqrvclb0yhakf25";
-  name = "mingw-w64-clang-x86_64-libxml2-2.12.8-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-libxml2-2.12.9-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -79,15 +79,15 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-headers-git-12.0.0.r81.g90abf784a-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 = "1h3cdcajz29iq7vja908kkijz1vb9xn0f7w1lw1ima0q0zhinv4q";
+  sha256 = "0163jzjlvq7inpafy3h48pkwag3ysk6x56xm84yfcz5q52fnfzq5";
-  name = "mingw-w64-clang-x86_64-headers-git-12.0.0.r81.g90abf784a-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-12.0.0.r81.g90abf784a-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 = "15kamyi3b0j6f5zxin4i2jgzjc7lzvwl4z5cz3dx0i8hg91aq0n7";
+  sha256 = "00cn1mi29mfys7qy4hvgnjd0smqvnkdn3ibnrr6a3wy1h2vaykgq";
-  name = "mingw-w64-clang-x86_64-crt-git-12.0.0.r81.g90abf784a-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 {
@ -97,15 +97,15 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r81.g90abf784a-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 = "0qdvgs1rmjjhn9klf9kpw7l0ydz36rr5fasn4q9gpby2lgl11bkb";
+  sha256 = "1zkzqqd31xpkv817wja3qssjjx891bsdxw07037hv2sk0qr4ffn9";
-  name = "mingw-w64-clang-x86_64-libwinpthread-git-12.0.0.r81.g90abf784a-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-12.0.0.r81.g90abf784a-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 = "0rh2mn078cifcmr4as4k57jxjln5lbnsmpx47h9d0s5d2i8sf2rc";
+  sha256 = "02ynia88ad3l03r08nyldmnajwqkyxcjd191lyamkbj4d6zck323";
-  name = "mingw-w64-clang-x86_64-winpthreads-git-12.0.0.r81.g90abf784a-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 {
@ -115,15 +115,15 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-c-ares-1.29.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 = "01xg1h1a8kda0kq2921w25ybvm1ms7lfdzday0hv93f3myq7briq";
+  sha256 = "14r6jjsvfbapbkv2zqp2yglva4vz4srzkgk7f186ri3kcafjspgq";
-  name = "mingw-w64-clang-x86_64-c-ares-1.29.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 {
@ -163,9 +163,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openssl-3.3.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 = "0ywhwm4kw3qjzv0872qwabnsq2rzbmqjb9m69q3fykjl0m9gigsa";
+  sha256 = "1djgpcz447yvhdy1yq5wh8l5d0821izxklx9afyszbw0pbr7f24y";
-  name = "mingw-w64-clang-x86_64-openssl-3.3.1-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-openssl-3.3.2-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -175,39 +175,39 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-nghttp2-1.61.0-2-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 = "07bkk98126gy4k6lb9rrqqnzjfz9j2rsr5dzr2djmzdkw0h4dr95";
+  sha256 = "0lfqrlmapsc7ilxjmhr7hxi578vclqlhpqimbvzq0c70c0iwk864";
-  name = "mingw-w64-clang-x86_64-nghttp2-1.61.0-2-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-nghttp3-1.4.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 = "007w2252nzn274j4wjc1vf56xyzzh5vg3blj1hil7mlmffgvc923";
+  sha256 = "1ljl9kdasf91bxkqcmbbjchp5g00ahv8jn2zab38899z6j3x43nz";
-  name = "mingw-w64-clang-x86_64-nghttp3-1.4.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-curl-8.8.0-10-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 = "024z5b1achkf448gxqy1i3gcw371x54kfl6igv08b5wb3rrw35a4";
+  sha256 = "1zr6kgqp9i4qqrfckh3kfmz4x1cwv4xis9sfqsx7xji88priax64";
-  name = "mingw-w64-clang-x86_64-curl-8.8.0-10-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-rust-1.79.0-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 = "0i7s88hj8m4920xifkj7i4b4sq8cqq7p5cypp3jqx3dc44pwm19a";
+  sha256 = "1dm4vlrfi9m6xl09zpn0yjr7qcjjr4x738z1rjfwysfnc0awq4x8";
-  name = "mingw-w64-clang-x86_64-rust-1.79.0-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-pkgconf-1~2.2.0-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 = "1y44ijg3y8p80f1yn9972nshrnyrd06a9sh984ajhxg8bi8s5xyl";
+  sha256 = "0phhwkcqp30dsyj5vr6w99sgm1jfm5rzg0w5x5mv9md4x7lm9lmh";
-  name = "mingw-w64-clang-x86_64-pkgconf-12.2.0-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.2-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
-  sha256 = "0kj1vzjh3qh7d2g47avlgk7a6j4nc62111hy1m63jwq0alc01k38";
+  sha256 = "19xfl1q78q1k8j0lr5aspcf668pmfg01fgib73zq7ff7y5y5fcyi";
-  name = "mingw-w64-clang-x86_64-expat-2.6.2-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-expat-2.6.3-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -229,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 {
@ -264,6 +264,12 @@
  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 {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-rhash-1.4.4-3-any.pkg.tar.zst";
  sha256 = "1ysbxirpfr0yf7pvyps75lnwc897w2a2kcid3nb4j6ilw6n64jmc";
@ -271,9 +277,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-cmake-3.30.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 = "07b7132hwhiqrf0l2lgw3g4zw9i2lln3kqc9kg2qijvkapbkmwqb";
+  sha256 = "0fjwf6xxzli6rcsbzr1razldmm538ibkyf5kw132lpaz5wma9bj8";
-  name = "mingw-w64-clang-x86_64-cmake-3.30.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-cmake-3.30.3-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -295,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 {
@ -307,9 +313,9 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-sqlite3-3.46.0-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 = "0q676i2z5nr4c71jnd4z5qz9xa1xryl0cpi84w74yvd0p4qiz7y2";
+  sha256 = "1axplxyjnaz411qzjjqwbj55fbrh4akq3plm2p1sx64jp844xpyq";
-  name = "mingw-w64-clang-x86_64-sqlite3-3.46.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-sqlite3-3.46.1-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
@ -324,6 +330,12 @@
  name = "mingw-w64-clang-x86_64-tzdata-2024a-1-any.pkg.tar.zst";
 })
 (pkgs.fetchurl {
  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python3.12-3.12.1-2-any.pkg.tar.zst";
  sha256 = "0wmd39wl9z237w093a7c6hl5pclca9yvwxn0kiw6i2njk3sjv51a";
  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-python-3.11.9-1-any.pkg.tar.zst";
  sha256 = "0ah1idjqxg7jc07a1gz9z766rjjd0f0c6ri4hpcsimsrbj1zjd3c";
@ -337,20 +349,20 @@
 })
 (pkgs.fetchurl {
-  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-openblas-0.3.27-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 = "06ygz1wa488wqvmxbn74b0fyan4wf3lb6kbwfampgikd1gijww2k";
+  sha256 = "1pskcqc1lg9p8m8rk7bw3mz7mn7vw5fpl7zxa23bhjn02p5b79qq";
-  name = "mingw-w64-clang-x86_64-openblas-0.3.27-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-numpy-1.26.4-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 = "00h0ap954cjwlsc3p01fjwy7s3nlzs90v0kmnrzxm0rljmvn4jkf";
+  sha256 = "0ks6q8v58h4wmr2pzsjl2xm4f63g0psvfm0jwlz24mqfxp8gqfcc";
-  name = "mingw-w64-clang-x86_64-python-numpy-1.26.4-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-70.2.0-1-any.pkg.tar.zst";
+  url = "https://mirror.msys2.org/mingw/clang64/mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
-  sha256 = "1q4r9bg2hn3jmshvq81xm5zvy9wn35yf0z2ayksrkwph1zzdkvkm";
+  sha256 = "0xc95z5jzzjf5lw35bs4yn5rlwkrkmrh78yi5rranqpz5nn0wsa0";
-  name = "mingw-w64-clang-x86_64-python-setuptools-70.2.0-1-any.pkg.tar.zst";
+  name = "mingw-w64-clang-x86_64-python-setuptools-74.0.0-1-any.pkg.tar.zst";
 })
 ]
Author	SHA1	Message	Date
occheung	979209a526	binop: expand `not` operator as loglcal not	2024-11-08 17:12:01 +08:00
David Mak	c3927d0ef6	[ast] Refactor lazy_static to LazyLock It is available in Rust 1.80 and reduces a dependency.	2024-10-30 12:29:51 +08:00
David Mak	202a902cd0	[meta] Update dependencies	2024-10-30 12:29:51 +08:00
David Mak	b6e2644391	[meta] Update cargo dependencies	2024-10-18 14:17:16 +08:00
David Mak	45cd01556b	[meta] Apply cargo fmt	2024-10-18 14:16:42 +08:00
David Mak	b6cd2a6993	[meta] Reorganize order of use declarations - Phase 3	2024-10-17 16:25:52 +08:00
David Mak	a98f33e6d1	[meta] Reorganize order of use declarations - Phase 2 Some more rules: - For module-level imports, prefer no prefix > super > crate. - Use crate instead of super if super refers to the crate-level module	2024-10-17 15:57:33 +08:00
David Mak	5839badadd	[standalone] Update globals.py with type-inferred global var	2024-10-07 20:44:08 +08:00
David Mak	56c845aac4	[standalone] Add support for registering globals without type decl	2024-10-07 20:44:06 +08:00
David Mak	65a12d9ab3	[core] Refactor registration of top-level variables	2024-10-07 17:05:48 +08:00
David Mak	9c6685fa8f	[core] typecheck/function_check: Fix lookup of defined ids in scope	2024-10-07 16:51:37 +08:00
David Mak	2bb788e4bb	[core] codegen/expr: Materialize implicit globals Required for when globals are read without the use of a global declaration.	2024-10-07 13:13:20 +08:00
David Mak	42a2f243b5	[core] typecheck: Disallow redeclaration of var shadowing global	2024-10-07 13:11:00 +08:00
David Mak	3ce2eddcdc	[core] typecheck/type_inferencer: Infer whether variables are global	2024-10-07 13:10:46 +08:00
David Mak	51bf126a32	[core] typecheck/type_inferencer: Differentiate global symbols Required for analyzing use of global symbols before global declaration.	2024-10-07 12:25:00 +08:00
David Mak	1a197c67f6	[core] toplevel/composer: Reduce lock scope while analyzing function	2024-10-05 15:53:20 +08:00
David Mak	581b2f7bb2	[standalone] Add demo for global variables	2024-10-04 13:24:30 +08:00
David Mak	746329ec5d	[standalone] Implement symbol resolution for globals	2024-10-04 13:24:30 +08:00
David Mak	e60e8e837f	[core] Add support for global statements	2024-10-04 13:24:27 +08:00
David Mak	9fdbe9695d	[core] Add generator to SymbolResolver::get_symbol_value Needed in a future commit.	2024-10-04 13:20:29 +08:00
David Mak	8065e73598	[core] toplevel/composer: Add type analysis for global variables	2024-10-04 13:20:29 +08:00
David Mak	192290889b	[core] Add IdentifierInfo Keeps track of whether an identifier refers to a global or local variable.	2024-10-04 13:20:24 +08:00
David Mak	1407553a2f	[core] Implement parsing of global variables Globals are now parsed into symbol resolver and top level definitions.	2024-10-04 13:18:29 +08:00
David Mak	c7697606e1	[core] Add TopLevelDef::Variable	2024-10-04 13:09:25 +08:00
David Mak	88d0ccbf69	[standalone] Explicit panic when encountering a compilation error Otherwise scripts will continue to execute.	2024-10-04 13:00:16 +08:00
David Mak	a43b59539c	[meta] Move variables declarations closer to where they are first used	2024-10-04 13:00:16 +08:00
David Mak	fe06b2806f	[meta] Reorganize order of use declarations Use declarations are now grouped into 4 groups: - Declarations from the standard library - Declarations from external crates - Declarations from other crates in this project - Declarations from within this module Furthermore, all use declarations are grouped together to enhance readability. super::super is also replaced by an equivalent crate:: declaration.	2024-10-04 12:52:01 +08:00
David Mak	7f6c9a25ac	[meta] Update Cargo dependencies	2024-10-04 12:52:01 +08:00
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