From 93a6ec6717b84c8d153916651235ab0925807af0 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Tue, 3 Feb 2026 16:04:59 +0000
Subject: [PATCH 01/13] Revert "WIP delete codegen related changes temporarily"

This reverts commit bf0866f726aeab0e705095d5bd529d8cca098f92.
---
 mypyc/codegen/emit.py       | 123 +++++++++++++++++++++++++++++++++++-
 mypyc/codegen/emitclass.py  |   4 +-
 mypyc/codegen/emitfunc.py   |  55 ++++++++--------
 mypyc/codegen/emitmodule.py |  16 ++++-
 mypyc/test/test_emitfunc.py |  97 ++++++++++++++++++++++++++--
 5 files changed, 258 insertions(+), 37 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index 409018d28410..f75f8d8a6bde 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -21,16 +21,25 @@
     REG_PREFIX,
     STATIC_PREFIX,
     TYPE_PREFIX,
+    TYPE_VAR_PREFIX,
 )
 from mypyc.ir.class_ir import ClassIR, all_concrete_classes
 from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncDecl, FuncIR, get_text_signature
-from mypyc.ir.ops import BasicBlock, Value
+from mypyc.ir.ops import (
+    NAMESPACE_MODULE,
+    NAMESPACE_STATIC,
+    NAMESPACE_TYPE,
+    NAMESPACE_TYPE_VAR,
+    BasicBlock,
+    Value,
+)
 from mypyc.ir.rtypes import (
     RInstance,
     RPrimitive,
     RTuple,
     RType,
     RUnion,
+    RVec,
     int_rprimitive,
     is_bool_or_bit_rprimitive,
     is_bytearray_rprimitive,
@@ -56,14 +65,24 @@
     is_uint8_rprimitive,
     object_rprimitive,
     optional_value_type,
+    vec_api_by_item_type,
+    vec_item_type_tags,
 )
 from mypyc.namegen import NameGenerator, exported_name
+from mypyc.primitives.registry import builtin_names
 from mypyc.sametype import is_same_type
 
 # Whether to insert debug asserts for all error handling, to quickly
 # catch errors propagating without exceptions set.
 DEBUG_ERRORS: Final = False
 
+PREFIX_MAP: Final = {
+    NAMESPACE_STATIC: STATIC_PREFIX,
+    NAMESPACE_TYPE: TYPE_PREFIX,
+    NAMESPACE_MODULE: MODULE_PREFIX,
+    NAMESPACE_TYPE_VAR: TYPE_VAR_PREFIX,
+}
+
 
 class HeaderDeclaration:
     """A representation of a declaration in C.
@@ -326,6 +345,13 @@ def ctype_spaced(self, rtype: RType) -> str:
         else:
             return ctype + " "
 
+    def set_undefined_value(self, target: str, rtype: RType) -> None:
+        if isinstance(rtype, RVec):
+            self.emit_line(f"{target}.len = -1;")
+            self.emit_line(f"{target}.buf = NULL;")
+        else:
+            self.emit_line(f"{target} = {self.c_undefined_value(rtype)};")
+
     def c_undefined_value(self, rtype: RType) -> str:
         if not rtype.is_unboxed:
             return "NULL"
@@ -333,6 +359,8 @@ def c_undefined_value(self, rtype: RType) -> str:
             return rtype.c_undefined
         elif isinstance(rtype, RTuple):
             return self.tuple_undefined_value(rtype)
+        elif isinstance(rtype, RVec):
+            return f"({self.ctype(rtype)}) {{ -1, NULL }}"
         assert False, rtype
 
     def c_error_value(self, rtype: RType) -> str:
@@ -435,6 +463,12 @@ def error_value_check(self, rtype: RType, value: str, compare: str) -> str:
             return self.tuple_undefined_check_cond(
                 rtype, value, self.c_error_value, compare, check_exception=False
             )
+        elif isinstance(rtype, RVec):
+            if compare == "==":
+                return f"{value}.len < 0"
+            elif compare == "!=":
+                return f"{value}.len >= 0"
+            assert False, compare
         else:
             return f"{value} {compare} {self.c_error_value(rtype)}"
 
@@ -466,6 +500,8 @@ def tuple_undefined_check_cond(
             return self.tuple_undefined_check_cond(
                 item_type, tuple_expr_in_c + f".f{i}", c_type_compare_val, compare
             )
+        elif isinstance(item_type, RVec):
+            return f"{tuple_expr_in_c}.f{i}.len {compare} -1"
         else:
             check = f"{tuple_expr_in_c}.f{i} {compare} {c_type_compare_val(item_type)}"
             if rtuple.error_overlap and check_exception:
@@ -485,6 +521,8 @@ def c_initializer_undefined_value(self, rtype: RType) -> str:
                 return f"{{ {int_rprimitive.c_undefined} }}"
             items = ", ".join([self.c_initializer_undefined_value(t) for t in rtype.types])
             return f"{{ {items} }}"
+        elif isinstance(rtype, RVec):
+            return "{ -1, NULL }"
         else:
             return self.c_undefined_value(rtype)
 
@@ -518,6 +556,9 @@ def emit_inc_ref(self, dest: str, rtype: RType, *, rare: bool = False) -> None:
         elif isinstance(rtype, RTuple):
             for i, item_type in enumerate(rtype.types):
                 self.emit_inc_ref(f"{dest}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            # TODO: Only use the X variant if buf can be NULL
+            self.emit_line(f"Py_XINCREF({dest}.buf);")
         elif not rtype.is_unboxed:
             # Always inline, since this is a simple but very hot op
             if rtype.may_be_immortal or not HAVE_IMMORTAL:
@@ -546,6 +587,12 @@ def emit_dec_ref(
         elif isinstance(rtype, RTuple):
             for i, item_type in enumerate(rtype.types):
                 self.emit_dec_ref(f"{dest}.f{i}", item_type, is_xdec=is_xdec, rare=rare)
+        elif isinstance(rtype, RVec):
+            # TODO: Only use the X variant if buf can be NULL
+            if rare:
+                self.emit_line(f"CPy_XDecRef({dest}.buf);")
+            else:
+                self.emit_line(f"CPy_XDECREF({dest}.buf);")
         elif not rtype.is_unboxed:
             if rare:
                 self.emit_line(f"CPy_{x}DecRef({dest});")
@@ -555,6 +602,8 @@ def emit_dec_ref(
                     self.emit_line(f"CPy_{x}DECREF({dest});")
                 else:
                     self.emit_line(f"CPy_{x}DECREF_NO_IMM({dest});")
+        elif rtype.is_refcounted:
+            assert False, f"dec_ref not implemented for {rtype}"
         # Otherwise assume it's an unboxed, pointerless value and do nothing.
 
     def pretty_name(self, typ: RType) -> str:
@@ -751,6 +800,14 @@ def emit_cast(
         elif isinstance(typ, RTuple):
             assert not optional
             self.emit_tuple_cast(src, dest, typ, declare_dest, error, src_type)
+        elif isinstance(typ, RVec):
+            # TODO: Actually perform the type check, this is a no-op
+            if declare_dest:
+                self.emit_line("PyObject *{};".format(dest))
+            self.emit_arg_check(src, dest, typ, "", optional)
+            self.emit_line("{} = {};".format(dest, src))
+            if optional:
+                self.emit_line("}")
         else:
             assert False, "Cast not implemented: %s" % typ
 
@@ -894,6 +951,7 @@ def emit_unbox(
             declare_dest: If True, also declare the variable 'dest'
             error: What happens on error
             raise_exception: If True, also raise TypeError on failure
+            optional: If True, NULL src value is allowed and will map to error value
             borrow: If True, create a borrowed reference
 
         """
@@ -1025,10 +1083,53 @@ def emit_unbox(
             self.emit_line("}")
             if optional:
                 self.emit_line("}")
+        elif isinstance(typ, RVec):
+            if declare_dest:
+                self.emit_line(f"{self.ctype(typ)} {dest};")
+
+            if optional:
+                self.emit_line(f"if ({src} == NULL) {{")
+                self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+                self.emit_line("} else {")
+
+            specialized_api_name = vec_api_by_item_type.get(typ.item_type)
+            if specialized_api_name is not None:
+                self.emit_line(f"{dest} = {specialized_api_name}.unbox({src});")
+            else:
+                depth = typ.depth()
+                unwrapped = typ.unwrap_item_type()
+                if unwrapped in vec_item_type_tags:
+                    type_value = str(vec_item_type_tags[unwrapped])
+                else:
+                    type_value = self.vec_item_type_c(typ)
+                if depth == 0:
+                    self.emit_line(f"{dest} = VecTApi.unbox({src}, {type_value});")
+                else:
+                    self.emit_line(f"{dest} = VecNestedApi.unbox({src}, {type_value}, {depth});")
+
+            self.emit_line(f"if (VEC_IS_ERROR({dest})) {{")
+            self.emit_line(failure)
+            self.emit_line("}")
 
+            if optional:
+                self.emit_line("}")
         else:
             assert False, "Unboxing not implemented: %s" % typ
 
+    def vec_item_type_c(self, typ: RVec) -> str:
+        item_type = typ.unwrap_item_type()
+        type_value = f"(size_t){self.type_c_ptr(item_type)}"
+        if typ.is_optional():
+            type_value = f"{type_value} | 1"
+        return type_value
+
+    def type_c_ptr(self, typ: RPrimitive | RInstance) -> str | None:
+        if isinstance(typ, RPrimitive) and typ.is_refcounted:
+            return "&" + builtin_names[typ.name][1]
+        elif isinstance(typ, RInstance):
+            return self.type_struct_name(typ.class_ir)
+        return None
+
     def emit_box(
         self, src: str, dest: str, typ: RType, declare_dest: bool = False, can_borrow: bool = False
     ) -> None:
@@ -1083,6 +1184,20 @@ def emit_box(
                         inner_name = self.temp_name()
                         self.emit_box(f"{src}.f{i}", inner_name, typ.types[i], declare_dest=True)
                         self.emit_line(f"PyTuple_SET_ITEM({dest}, {i}, {inner_name});")
+        elif isinstance(typ, RVec):
+            specialized_api_name = vec_api_by_item_type.get(typ.item_type)
+            if specialized_api_name is not None:
+                api = specialized_api_name
+            elif typ.depth() > 0:
+                api = "VecNestedApi"
+            else:
+                api = "VecTApi"
+                # Empty vecs of this sort don't describe item type, so it needs to be
+                # passed explicitly.
+                item_type = self.vec_item_type_c(typ)
+                self.emit_line(f"{declaration}{dest} = {api}.box({src}, {item_type});")
+                return
+            self.emit_line(f"{declaration}{dest} = {api}.box({src});")
         else:
             assert not typ.is_unboxed
             # Type is boxed -- trivially just assign.
@@ -1096,6 +1211,8 @@ def emit_error_check(self, value: str, rtype: RType, failure: str) -> None:
             else:
                 cond = self.tuple_undefined_check_cond(rtype, value, self.c_error_value, "==")
                 self.emit_line(f"if ({cond}) {{")
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"if ({value}.len < 0) {{")
         elif rtype.error_overlap:
             # The error value is also valid as a normal value, so we need to also check
             # for a raised exception.
@@ -1120,6 +1237,8 @@ def emit_gc_visit(self, target: str, rtype: RType) -> None:
         elif isinstance(rtype, RTuple):
             for i, item_type in enumerate(rtype.types):
                 self.emit_gc_visit(f"{target}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"Py_VISIT({target}.buf);")
         elif self.ctype(rtype) == "PyObject *":
             # The simplest case.
             self.emit_line(f"Py_VISIT({target});")
@@ -1144,6 +1263,8 @@ def emit_gc_clear(self, target: str, rtype: RType) -> None:
         elif isinstance(rtype, RTuple):
             for i, item_type in enumerate(rtype.types):
                 self.emit_gc_clear(f"{target}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"Py_CLEAR({target}.buf);")
         elif self.ctype(rtype) == "PyObject *" and self.c_undefined_value(rtype) == "NULL":
             # The simplest case.
             self.emit_line(f"Py_CLEAR({target});")
diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index 8c3fa5de98f8..387065d93bcf 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -653,7 +653,7 @@ def generate_setup_for_class(
             # We don't need to set this field to NULL since tp_alloc() already
             # zero-initializes `self`.
             if value != "NULL":
-                emitter.emit_line(rf"self->{emitter.attr(attr)} = {value};")
+                emitter.set_undefined_value(f"self->{emitter.attr(attr)}", rtype)
 
     # Initialize attributes to default values, if necessary
     if defaults_fn is not None:
@@ -1194,7 +1194,7 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
 
     if deletable:
         emitter.emit_line("} else")
-        emitter.emit_line(f"    self->{attr_field} = {emitter.c_undefined_value(rtype)};")
+        emitter.set_undefined_value(f"    self->{attr_field}", rtype)
         if rtype.error_overlap:
             emitter.emit_attr_bitmap_clear("self", rtype, cl, attr)
     emitter.emit_line("return 0;")
diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py
index 3f1bbab58895..c1202d1c928c 100644
--- a/mypyc/codegen/emitfunc.py
+++ b/mypyc/codegen/emitfunc.py
@@ -5,25 +5,19 @@
 from typing import Final
 
 from mypyc.analysis.blockfreq import frequently_executed_blocks
-from mypyc.codegen.emit import DEBUG_ERRORS, Emitter, TracebackAndGotoHandler, c_array_initializer
-from mypyc.common import (
-    GENERATOR_ATTRIBUTE_PREFIX,
-    HAVE_IMMORTAL,
-    MODULE_PREFIX,
-    NATIVE_PREFIX,
-    REG_PREFIX,
-    STATIC_PREFIX,
-    TYPE_PREFIX,
-    TYPE_VAR_PREFIX,
+from mypyc.codegen.emit import (
+    DEBUG_ERRORS,
+    PREFIX_MAP,
+    Emitter,
+    TracebackAndGotoHandler,
+    c_array_initializer,
 )
+from mypyc.common import GENERATOR_ATTRIBUTE_PREFIX, HAVE_IMMORTAL, NATIVE_PREFIX, REG_PREFIX
 from mypyc.ir.class_ir import ClassIR
 from mypyc.ir.func_ir import FUNC_CLASSMETHOD, FUNC_STATICMETHOD, FuncDecl, FuncIR, all_values
 from mypyc.ir.ops import (
     ERR_FALSE,
-    NAMESPACE_MODULE,
-    NAMESPACE_STATIC,
     NAMESPACE_TYPE,
-    NAMESPACE_TYPE_VAR,
     Assign,
     AssignMulti,
     BasicBlock,
@@ -82,6 +76,7 @@
     RStruct,
     RTuple,
     RType,
+    RVec,
     is_bool_or_bit_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
@@ -221,6 +216,10 @@ def error_value_check(self, value: Value, compare: str) -> str:
             return self.emitter.tuple_undefined_check_cond(
                 typ, self.reg(value), self.c_error_value, compare
             )
+        elif isinstance(typ, RVec):
+            # Error values for vecs are represented by a negative length.
+            vec_compare = ">=" if compare == "!=" else "<"
+            return f"{self.reg(value)}.len {vec_compare} 0"
         else:
             return f"{self.reg(value)} {compare} {self.c_error_value(typ)}"
 
@@ -289,10 +288,16 @@ def visit_assign(self, op: Assign) -> None:
         # clang whines about self assignment (which we might generate
         # for some casts), so don't emit it.
         if dest != src:
-            # We sometimes assign from an integer prepresentation of a pointer
-            # to a real pointer, and C compilers insist on a cast.
-            if op.src.type.is_unboxed and not op.dest.type.is_unboxed:
+            src_type = op.src.type
+            dest_type = op.dest.type
+            if src_type.is_unboxed and not dest_type.is_unboxed:
+                # We sometimes assign from an integer prepresentation of a pointer
+                # to a real pointer, and C compilers insist on a cast.
                 src = f"(void *){src}"
+            elif not src_type.is_unboxed and dest_type.is_unboxed:
+                # We sometimes assign a pointer to an integer type (e.g. to create
+                # tagged pointers), and here we need an explicit cast.
+                src = f"({self.emitter.ctype(dest_type)}){src}"
             self.emit_line(f"{dest} = {src};")
 
     def visit_assign_multi(self, op: AssignMulti) -> None:
@@ -312,11 +317,14 @@ def visit_assign_multi(self, op: AssignMulti) -> None:
         )
 
     def visit_load_error_value(self, op: LoadErrorValue) -> None:
+        reg = self.reg(op)
         if isinstance(op.type, RTuple):
             values = [self.c_undefined_value(item) for item in op.type.types]
             tmp = self.temp_name()
             self.emit_line("{} {} = {{ {} }};".format(self.ctype(op.type), tmp, ", ".join(values)))
-            self.emit_line(f"{self.reg(op)} = {tmp};")
+            self.emit_line(f"{reg} = {tmp};")
+        elif isinstance(op.type, RVec):
+            self.emitter.set_undefined_value(reg, op.type)
         else:
             self.emit_line(f"{self.reg(op)} = {self.c_error_value(op.type)};")
 
@@ -523,16 +531,9 @@ def visit_set_attr(self, op: SetAttr) -> None:
             if op.error_kind == ERR_FALSE:
                 self.emitter.emit_line(f"{dest} = 1;")
 
-    PREFIX_MAP: Final = {
-        NAMESPACE_STATIC: STATIC_PREFIX,
-        NAMESPACE_TYPE: TYPE_PREFIX,
-        NAMESPACE_MODULE: MODULE_PREFIX,
-        NAMESPACE_TYPE_VAR: TYPE_VAR_PREFIX,
-    }
-
     def visit_load_static(self, op: LoadStatic) -> None:
         dest = self.reg(op)
-        prefix = self.PREFIX_MAP[op.namespace]
+        prefix = PREFIX_MAP[op.namespace]
         name = self.emitter.static_name(op.identifier, op.module_name, prefix)
         if op.namespace == NAMESPACE_TYPE:
             name = "(PyObject *)%s" % name
@@ -540,7 +541,7 @@ def visit_load_static(self, op: LoadStatic) -> None:
 
     def visit_init_static(self, op: InitStatic) -> None:
         value = self.reg(op.value)
-        prefix = self.PREFIX_MAP[op.namespace]
+        prefix = PREFIX_MAP[op.namespace]
         name = self.emitter.static_name(op.identifier, op.module_name, prefix)
         if op.namespace == NAMESPACE_TYPE:
             value = "(PyTypeObject *)%s" % value
@@ -845,7 +846,7 @@ def visit_load_address(self, op: LoadAddress) -> None:
         if isinstance(op.src, Register):
             src = self.reg(op.src)
         elif isinstance(op.src, LoadStatic):
-            prefix = self.PREFIX_MAP[op.src.namespace]
+            prefix = PREFIX_MAP[op.src.namespace]
             src = self.emitter.static_name(op.src.identifier, op.src.module_name, prefix)
         else:
             src = op.src
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index da82f14e92f2..554379b8848a 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -27,7 +27,7 @@
 from mypy.options import Options
 from mypy.plugin import Plugin, ReportConfigContext
 from mypy.util import hash_digest, json_dumps
-from mypyc.analysis.capsule_deps import find_implicit_op_dependencies
+from mypyc.analysis.capsule_deps import find_class_dependencies, find_implicit_op_dependencies
 from mypyc.codegen.cstring import c_string_initializer
 from mypyc.codegen.emit import (
     Emitter,
@@ -56,7 +56,7 @@
     short_id_from_name,
 )
 from mypyc.errors import Errors
-from mypyc.ir.deps import LIBRT_BASE64, LIBRT_STRINGS, LIBRT_TIME, SourceDep
+from mypyc.ir.deps import LIBRT_BASE64, LIBRT_STRINGS, LIBRT_TIME, LIBRT_VECS, SourceDep
 from mypyc.ir.func_ir import FuncIR
 from mypyc.ir.module_ir import ModuleIR, ModuleIRs, deserialize_modules
 from mypyc.ir.ops import DeserMaps, LoadLiteral
@@ -271,6 +271,12 @@ def compile_scc_to_ir(
             do_copy_propagation(fn, compiler_options)
             do_flag_elimination(fn, compiler_options)
 
+        # Calculate implicit dependencies from class attribute types
+        for cl in module.classes:
+            deps = find_class_dependencies(cl)
+            if deps is not None:
+                module.dependencies.update(deps)
+
     return modules
 
 
@@ -634,6 +640,8 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
             ext_declarations.emit_line("#include <strings/librt_strings.h>")
         if any(LIBRT_TIME in mod.dependencies for mod in self.modules.values()):
             ext_declarations.emit_line("#include <time/librt_time.h>")
+        if any(LIBRT_VECS in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line('#include "vecs/librt_vecs.h"')
         # Include headers for conditional source files
         source_deps = collect_source_dependencies(self.modules)
         for source_dep in sorted(source_deps, key=lambda d: d.path):
@@ -1108,6 +1116,10 @@ def emit_module_exec_func(
             emitter.emit_line("if (import_librt_time() < 0) {")
             emitter.emit_line("return -1;")
             emitter.emit_line("}")
+        if LIBRT_VECS in module.dependencies:
+            emitter.emit_line("if (import_librt_vecs() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
         emitter.emit_line("PyObject* modname = NULL;")
         if self.multi_phase_init:
             emitter.emit_line(f"{module_static} = module;")
diff --git a/mypyc/test/test_emitfunc.py b/mypyc/test/test_emitfunc.py
index 642e1cd5c3cc..59ab4cb8a0e5 100644
--- a/mypyc/test/test_emitfunc.py
+++ b/mypyc/test/test_emitfunc.py
@@ -50,6 +50,8 @@
     RStruct,
     RTuple,
     RType,
+    RUnion,
+    RVec,
     bool_rprimitive,
     c_int_rprimitive,
     cstring_rprimitive,
@@ -62,6 +64,7 @@
     object_rprimitive,
     pointer_rprimitive,
     short_int_rprimitive,
+    str_rprimitive,
 )
 from mypyc.irbuild.vtable import compute_vtable
 from mypyc.namegen import NameGenerator
@@ -109,6 +112,11 @@ def add_local(name: str, rtype: RType) -> Register:
         self.tt = add_local(
             "tt", RTuple([RTuple([int_rprimitive, bool_rprimitive]), bool_rprimitive])
         )
+        self.vi64 = add_local("vi64", RVec(int64_rprimitive))
+        self.vi32 = add_local("vi32", RVec(int32_rprimitive))
+        self.vs = add_local("vs", RVec(str_rprimitive))
+        self.vs_opt = add_local("vs", RVec(RUnion([str_rprimitive, none_rprimitive])))
+        self.vvs = add_local("vvs", RVec(RVec(str_rprimitive)))
         ir = ClassIR("A", "mod")
         ir.attributes = {
             "x": bool_rprimitive,
@@ -348,11 +356,11 @@ def test_unbox_int(self) -> None:
         self.assert_emit(
             Unbox(self.m, int_rprimitive, 55),
             """if (likely(PyLong_Check(cpy_r_m)))
-                                cpy_r_r0 = CPyTagged_FromObject(cpy_r_m);
-                            else {
-                                CPy_TypeError("int", cpy_r_m); cpy_r_r0 = CPY_INT_TAG;
-                            }
-                         """,
+                   cpy_r_r0 = CPyTagged_FromObject(cpy_r_m);
+               else {
+                   CPy_TypeError("int", cpy_r_m); cpy_r_r0 = CPY_INT_TAG;
+               }
+               """,
         )
 
     def test_box_i64(self) -> None:
@@ -363,6 +371,85 @@ def test_unbox_i64(self) -> None:
             Unbox(self.o, int64_rprimitive, 55), """cpy_r_r0 = CPyLong_AsInt64(cpy_r_o);"""
         )
 
+    def test_box_vec(self) -> None:
+        self.assert_emit(Box(self.vi64), """cpy_r_r0 = VecI64Api.box(cpy_r_vi64);""")
+        self.assert_emit(Box(self.vi32), """cpy_r_r0 = VecI32Api.box(cpy_r_vi32);""")
+        self.assert_emit(
+            Box(self.vs), """cpy_r_r0 = VecTApi.box(cpy_r_vs, (size_t)&PyUnicode_Type);"""
+        )
+        self.assert_emit(
+            Box(self.vs_opt), """cpy_r_r0 = VecTApi.box(cpy_r_vs, (size_t)&PyUnicode_Type | 1);"""
+        )
+        self.assert_emit(Box(self.vvs), """cpy_r_r0 = VecNestedApi.box(cpy_r_vvs);""")
+
+    def test_unbox_vec(self) -> None:
+        self.assert_emit(
+            Unbox(self.o, RVec(int64_rprimitive), 55),
+            """cpy_r_r0 = VecI64Api.unbox(cpy_r_o);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[i64]", cpy_r_o); cpy_r_r0 = (VecI64) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(int32_rprimitive), 55),
+            """cpy_r_r0 = VecI32Api.unbox(cpy_r_o);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[i32]", cpy_r_o); cpy_r_r0 = (VecI32) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(str_rprimitive), 55),
+            """cpy_r_r0 = VecTApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[str]", cpy_r_o); cpy_r_r0 = (VecT) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(RUnion([str_rprimitive, none_rprimitive])), 55),
+            """cpy_r_r0 = VecTApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type | 1);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[str | None]", cpy_r_o); cpy_r_r0 = (VecT) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(self.r.type), 55),
+            """cpy_r_r0 = VecTApi.unbox(cpy_r_o, (size_t)CPyType_A);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[mod.A]", cpy_r_o); cpy_r_r0 = (VecT) { -1, NULL };
+               }
+               """,
+        )
+
+    def test_unbox_vec_nested(self) -> None:
+        self.assert_emit(
+            Unbox(self.o, RVec(RVec(str_rprimitive)), 55),
+            """cpy_r_r0 = VecNestedApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type, 1);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[vec[str]]", cpy_r_o); cpy_r_r0 = (VecNested) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(RVec(RUnion([str_rprimitive, none_rprimitive]))), 55),
+            """cpy_r_r0 = VecNestedApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type | 1, 1);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[vec[str | None]]", cpy_r_o); cpy_r_r0 = (VecNested) { -1, NULL };
+               }
+               """,
+        )
+        self.assert_emit(
+            Unbox(self.o, RVec(RVec(int64_rprimitive)), 55),
+            """cpy_r_r0 = VecNestedApi.unbox(cpy_r_o, 2, 1);
+               if (VEC_IS_ERROR(cpy_r_r0)) {
+                   CPy_TypeError("vec[vec[i64]]", cpy_r_o); cpy_r_r0 = (VecNested) { -1, NULL };
+               }
+               """,
+        )
+
     def test_list_append(self) -> None:
         self.assert_emit(
             CallC(

From 9df50954da5ea6b11196d29581a1fb306690d746 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Tue, 3 Feb 2026 16:05:13 +0000
Subject: [PATCH 02/13] Revert "WIP temporarily delete vec run tests"

This reverts commit 8484cf89743d1cf7f005a68badbb6dc1625e6381.
---
 mypyc/test-data/run-vecs-i64.test    | 466 ++++++++++++++++++++++++++
 mypyc/test-data/run-vecs-misc.test   | 222 +++++++++++++
 mypyc/test-data/run-vecs-nested.test | 468 +++++++++++++++++++++++++++
 mypyc/test-data/run-vecs-t.test      | 406 +++++++++++++++++++++++
 4 files changed, 1562 insertions(+)
 create mode 100644 mypyc/test-data/run-vecs-i64.test
 create mode 100644 mypyc/test-data/run-vecs-misc.test
 create mode 100644 mypyc/test-data/run-vecs-nested.test
 create mode 100644 mypyc/test-data/run-vecs-t.test

diff --git a/mypyc/test-data/run-vecs-i64.test b/mypyc/test-data/run-vecs-i64.test
new file mode 100644
index 000000000000..326561d25a64
--- /dev/null
+++ b/mypyc/test-data/run-vecs-i64.test
@@ -0,0 +1,466 @@
+-- Test cases for vec[i64]. These also partially cover other unboxed item types,
+-- which use a similar runtime representation.
+
+[case testVecI64BasicOps_librt_experimental]
+from typing import Final, Any, Iterable, Tuple
+
+from mypy_extensions import i64, i32
+from librt.vecs import vec, append, remove, pop
+
+from testutil import assertRaises
+
+ERROR: Final = -113
+
+def test_create_empty() -> None:
+    v = vec[i64]()
+    assert len(v) == 0
+
+def test_create_from_list_and_get_item() -> None:
+    v = vec[i64]([])
+    assert len(v) == 0
+
+    v = vec[i64]([ERROR, 0, 255, int() + (2**63 - 1)])
+    assert len(v) == 4
+    assert v[0] == -113
+    assert v[1] == 0
+    assert v[2] == 255
+    assert v[3] == 2**63 - 1
+
+    v = vec[i64]([1, 2, 3, 4, 5, 6, 7, 8, 9])
+    assert len(v) == 9
+    for i in range(i64(9)):
+        assert v[i] == i + 1
+
+def test_append() -> None:
+    v = vec[i64]()
+    v = append(v, int() + 3)
+    assert len(v) == 1
+    x: i64 = ERROR + int()
+    v = append(v, x)
+    assert len(v) == 2
+    assert v[0] == 3
+    assert v[1] == ERROR
+    v = vec[i64]()
+    for i in range(1024):
+        v = append(v, i * 3)
+    assert len(v) == 1024
+    for i in range(1024):
+        assert v[i] == i * 3
+
+def test_get_item() -> None:
+    v = vec[i64]([3, 4])
+    x: i64 = int()
+    assert v[x] == 3
+    assert v[int()] == 3
+    x += 1
+    assert v[x] == 4
+    assert v[int() + 1] == 4
+    with assertRaises(IndexError):
+        v[x + 1]
+    with assertRaises(IndexError):
+        v[2]
+    with assertRaises(IndexError):
+        v[2**63 - 1]
+
+def test_get_item_negative() -> None:
+    v = vec[i64]([3, 4])
+    x: i64 = int() - 1
+    assert v[x] == 4
+    assert v[int() - 2] == 3
+    x -= 1
+    assert v[x] == 3
+    assert v[int() - 1] == 4
+    with assertRaises(IndexError):
+        v[x - 1]
+    with assertRaises(IndexError):
+        v[-3]
+    with assertRaises(IndexError):
+        v[-2**63]
+    with assertRaises(IndexError):
+        v[int() - 3]
+
+def test_set_item() -> None:
+    v = vec[i64]([3, 4])
+    v[0] = 0
+    assert v[0] == 0
+
+    x: i64 = int()
+
+    v[x] = 4
+    assert v[x] == 4
+
+    v[int()] = 5
+    assert v[int()] == 5
+
+    x += 1
+
+    v[x] = -5
+    assert v[x] == -5
+
+    v[1 + int()] = ERROR
+    assert v[1] == ERROR
+
+    with assertRaises(IndexError):
+        v[1 + x] = 6
+    with assertRaises(IndexError):
+        v[2 + int()] = 6
+
+def test_set_item_negative() -> None:
+    v = vec[i64]([3, 4])
+    v[-1] = 0
+    assert v[-1] == 0
+
+    x: i64 = int() - 1
+
+    v[x] = 4
+    assert v[x] == 4
+
+    v[int() - 2] = 5
+    assert v[int() - 2] == 5
+
+    x -= 1
+
+    v[x] = -5
+    assert v[x] == -5
+
+    v[-1 + int()] = ERROR
+    assert v[-1] == ERROR
+
+    with assertRaises(IndexError):
+        v[x - 1] = 6
+    with assertRaises(IndexError):
+        v[int() - 3] = 6
+
+def test_operator_assignment() -> None:
+    v = vec[i64]([3, 4])
+    x: i64 = int()
+    v[x] += 2
+    assert v[0] == 5
+    v[x + 1] -= 10
+    assert v[1] == -6
+    y = int()
+    v[y] += 6
+    assert v[y] == 11
+    v[y + 1] *= 2
+    assert v[1 + y] == -12
+
+def test_box_and_unbox() -> None:
+    v = vec[i64]([3, 5])
+    o: Any = v
+    assert len(o) == 2
+    assert o[0] == 3
+    assert o[1] == 5
+    o[1] = 6
+    v2: vec[i64] = o
+    assert len(v2) == 2
+    assert v2[0] == 3
+    assert v2[1] == 6
+    o2: Any = "x"
+    with assertRaises(TypeError, "vec[i64] object expected; got str"):
+        v2 = o2
+    o3: Any = vec[str]([])
+    # TODO: Better message
+    with assertRaises(TypeError, "vec[i64] object expected; got vec"):
+        v2 = o3
+
+def check_opt(x: vec[i64] | None, is_none: bool) -> None:
+    if is_none:
+        assert x is None
+    else:
+        if int() + 1:
+            assert x is not None
+            assert len(x) == 1
+            assert x[0] == 5
+        if int() + 2:
+            assert isinstance(x, vec)
+            assert len(x) == 1
+            assert x[0] == 5
+    if isinstance(x, vec):
+        assert x[0] == 5
+        assert not is_none
+    else:
+        assert is_none
+
+def test_vec_optional() -> None:
+    v = vec[i64]([5])
+    check_opt(None, True)
+    check_opt(v, False)
+    a1: Any = None
+    check_opt(a1, True)
+    a2: Any = v
+    check_opt(a2, False)
+    a3: Any = str
+    with assertRaises(TypeError):
+        check_opt(a3, False)
+
+def check_union(x: vec[i64] | str, is_str: bool) -> None:
+    if is_str:
+        assert isinstance(x, str)
+        assert x == "ss"
+    else:
+        if int() + 1:
+            assert not isinstance(x, str)
+            assert len(x) == 1
+            assert x[0] == 5
+        if int() + 2:
+            assert isinstance(x, vec)
+            assert len(x) == 1
+            assert x[0] == 5
+    if isinstance(x, vec):
+        assert x[0] == 5
+        assert not is_str
+    else:
+        assert is_str
+        assert x == "ss"
+
+def test_vec_union() -> None:
+    v = vec[i64]([5])
+    check_union("ss", True)
+    check_union(v, False)
+    a1: Any = "ss"
+    check_union(a1, True)
+    a2: Any = v
+    check_union(a2, False)
+    a3: Any = b"ss"
+    with assertRaises(TypeError):
+        check_union(a3, False)
+    a4: Any = vec[i32]()
+    with assertRaises(TypeError, 'vec[i64] object expected; got vec[i32]'):
+        check_union(a4, False)
+
+def test_construct_from_list_multiply() -> None:
+    for i in range(50):
+        v = vec[i64]([i + 1] * i)
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == i + 1
+    for i in range(50):
+        v = vec[i64](i * [i - 1])
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == i - 1
+
+def test_construct_from_list_comprehension() -> None:
+    for i in range(50):
+        l = [i * i for i in range(i)]
+        v = vec[i64]([n + 5 for n in l])
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == j * j + 5
+
+def test_construct_from_range() -> None:
+    v = vec[i64](range(0))
+    assert v == vec[i64]()
+    v = vec[i64](range(5))
+    assert v == vec[i64]([0, 1, 2, 3, 4])
+    v = vec[i64](range(2, 5))
+    assert v == vec[i64]([2, 3, 4])
+
+def test_construct_from_iterable() -> None:
+    for i in range(50):
+        it: Iterable[i64] = iter([i * i for i in range(i)])
+        v = vec[i64](it)
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == j * j
+    for i in range(50):
+        it2: Iterable[int] = iter([i * i for i in range(i)])
+        v = vec[i64](it2)
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == j * j
+
+def test_equality() -> None:
+    v0 = vec[i64]()
+    v0b = vec[i64]()
+    v1 = vec[i64]([1])
+    v1b = vec[i64]([3])
+    assert v0 == v0
+    assert v1 == v1
+    assert v0 == v0b
+    assert v0 != v1
+    assert v1 != v1b
+    assert v1 != v0
+
+def test_str_conversion() -> None:
+    v = vec[i64]()
+    assert str(v) == "vec[i64]([])"
+    assert repr(v) == "vec[i64]([])"
+    v = vec[i64]([126])
+    assert str(v) == "vec[i64]([126])"
+    v = append(v, -5)
+    assert str(v) == "vec[i64]([126, -5])"
+    v = append(v, ERROR)
+    assert str(v) == "vec[i64]([126, -5, -113])"
+
+def test_for_loop() -> None:
+    for n in vec[i64]():
+        assert False
+    a = []
+    for n in vec[i64]([5]):
+        a.append(n)
+    assert a == [5]
+    v = vec[i64]([ERROR, 9, 8])
+    a = []
+    for n in v:
+        a.append(n)
+    assert a == [ERROR, 9, 8]
+    assert len(v) == 3
+
+def test_contains() -> None:
+    v = vec[i64]()
+    x: i64 = int()
+    assert x not in v
+    v = vec[i64]([0])
+    assert x in v
+    assert x + 1 not in v
+    v2 = vec[i64]([ERROR, 7, 9])
+    assert x + ERROR in v2
+    assert x + 7 in v2
+    assert int() + 9 in v2
+    assert x not in v2
+    assert int() not in v2
+
+def test_slicing() -> None:
+    v = vec[i64]()
+    assert v[:] == vec[i64]([])
+    assert v[1:] == vec[i64]([])
+    assert v[:-5] == vec[i64]([])
+    v = vec[i64]([0, 1, 2, 3, 4])
+    assert v[1:4] == vec[i64]([1, 2, 3])
+    assert v[2:-1] == vec[i64]([2, 3])
+    assert v[-2:-1] == vec[i64]([3])
+    assert v[1:] == vec[i64]([1, 2, 3, 4])
+    assert v[:-1] == vec[i64]([0, 1, 2, 3])
+    assert v[:] == v
+    assert v[:] is not v
+    assert v[5:] == vec[i64]()
+    assert v[100:] == vec[i64]()
+    assert v[0:5] ==v
+    assert v[0:5] is not v
+    assert v[2:100] == vec[i64]([2, 3, 4])
+    assert v[-100:2] == vec[i64]([0, 1])
+    assert v[5:100] == vec[i64]([])
+    assert v[50:100] == vec[i64]([])
+    assert v[-100:-50] == vec[i64]([])
+
+def test_slicing_with_step() -> None:
+    v = vec[i64]([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    assert v[1:5:2] == vec[i64]([1, 3])
+    assert v[1:6:2] == vec[i64]([1, 3, 5])
+    assert v[5:1:-2] == vec[i64]([5, 3])
+    assert v[6:1:-2] == vec[i64]([6, 4, 2])
+    v = vec[i64]([0, 1, 2, 3, 4])
+    assert v[::-1] == vec[i64]([4, 3, 2, 1, 0])
+    with assertRaises(ValueError):
+        v[1:3:0]
+
+def test_remove() -> None:
+    a = [4, 7, ERROR]
+    for i in a:
+        v = vec[i64](a)
+        v = remove(v, i)
+        assert v == vec[i64]([j for j in a if j != i])
+    v = vec[i64](a)
+    v = remove(v, 4)
+    v = remove(v, 7)
+    v = remove(v, ERROR)
+    assert v == vec[i64]()
+    with assertRaises(ValueError):
+        remove(v, 4)
+    v = append(v, 5)
+    with assertRaises(ValueError):
+        remove(v, 7)
+    v = remove(v, 5)
+    assert len(v) == 0
+    v = vec[i64]([1, 1, 1])
+    v = remove(v, 1)
+    assert v == vec[i64]([1, 1])
+    v = remove(v, 1)
+    assert v == vec[i64]([1])
+    v = remove(v, 1)
+    assert v == vec[i64]()
+    f: Any = 1.1
+    with assertRaises(TypeError):
+        remove(v, f)
+    s: Any = 'x'
+    with assertRaises(TypeError):
+        remove(v, s)
+
+def test_pop_last() -> None:
+    v = vec[i64]([4, 7, ERROR])
+    v, n = pop(v)
+    assert n == ERROR
+    assert v == vec[i64]([4, 7])
+    v, n = pop(v)
+    assert n == 7
+    assert v == vec[i64]([4])
+    v, n = pop(v)
+    assert n == 4
+    assert v == vec[i64]()
+    with assertRaises(IndexError):
+       pop(v)
+
+def test_pop_index() -> None:
+    v = vec[i64]([4, 7, 9, 15, 22])
+    v, n = pop(v, 0)
+    assert n == 4
+    assert v == vec[i64]([7, 9, 15, 22])
+    v, n = pop(v, -1)
+    assert n == 22
+    assert v == vec[i64]([7, 9, 15])
+    v, n = pop(v, 1)
+    assert n == 9
+    assert v == vec[i64]([7, 15])
+
+    with assertRaises(IndexError):
+       pop(v, 2)
+
+    with assertRaises(IndexError):
+       pop(v, -3)
+
+    v, n = pop(v, -2)
+    assert n == 7
+    assert v == vec[i64]([15])
+    v, n = pop(v, 0)
+    assert n == 15
+    assert v == vec[i64]()
+
+def f(x: vec[i64]) -> None:
+    pass
+
+def test_wrapper_arg_check() -> None:
+    f_any: Any = f
+    with assertRaises(TypeError):
+        f_any([])
+
+v: Final = vec[i64]([5, 6])
+
+def test_final() -> None:
+    assert v == vec[i64]([5, 6])
+
+def fdefault(v: vec[i64] = vec[i64]([5])) -> vec[i64]:
+    return v
+
+def test_default_arg() -> None:
+    assert fdefault() == vec[i64]([5])
+    assert fdefault(vec[i64]()) == vec[i64]()
+    f_any: Any = fdefault
+    assert f_any() == vec[i64]([5])
+    assert f_any(vec[i64]([6])) == vec[i64]([6])
+
+def ftuple(b: bool) -> Tuple[vec[i64], vec[i64]]:
+    if b:
+        raise RuntimeError()
+    return vec[i64]([5]), vec[i64]()
+
+def test_tuple() -> None:
+    t = ftuple(False)
+    assert len(t) == 2
+    assert t[0] == vec[i64]([5])
+    assert t[1] == vec[i64]()
+    a, b = t
+    assert a == t[0]
+    assert b == t[1]
+    with assertRaises(RuntimeError):
+        ftuple(True)
diff --git a/mypyc/test-data/run-vecs-misc.test b/mypyc/test-data/run-vecs-misc.test
new file mode 100644
index 000000000000..0ef4021c4a51
--- /dev/null
+++ b/mypyc/test-data/run-vecs-misc.test
@@ -0,0 +1,222 @@
+-- Test cases for packed/specialized vec item types other than i64, such as
+-- vec[i32] and vec[float]. Since many of the code paths are the same as for
+-- vec[i64], only test a subset of functionality.
+--
+-- vec[i64] test cases are in run-vecs-i64.test.
+
+[case testVecMiscBasicOps_librt_experimental]
+# mypy: allow-redefinition
+
+from typing import Any, cast
+from mypy_extensions import i64, i32, i16, u8
+from librt.vecs import vec, append, remove, pop
+from testutil import assertRaises
+
+def test_create_empty() -> None:
+    assert str(vec[i32]()) == "vec[i32]([])"
+    assert str(vec[i16]()) == "vec[i16]([])"
+    assert str(vec[u8]()) == "vec[u8]([])"
+    assert str(vec[float]()) == "vec[float]([])"
+    assert str(vec[bool]()) == "vec[bool]([])"
+
+def test_create_from_values() -> None:
+    assert str(vec[i32]([5, -12])) == "vec[i32]([5, -12])"
+    assert str(vec[i16]([6, -8])) == "vec[i16]([6, -8])"
+    assert str(vec[u8]([0, 123, 255])) == "vec[u8]([0, 123, 255])"
+    assert str(vec[float]([1.5, -3.5])) == "vec[float]([1.5, -3.5])"
+    assert str(vec[bool]([False, True])) == "vec[bool]([False, True])"
+
+def test_get_item() -> None:
+    assert vec[i32]([5, -12])[1] == -12
+    assert vec[i16]([6, -8])[1] == -8
+    assert vec[u8]([0, 123, 255])[2] == 255
+    assert vec[float]([1.5, -3.5])[1] == -3.5
+    assert vec[bool]([False, True])[1] == True
+
+def test_get_item_negative() -> None:
+    assert vec[i32]([5, -12])[-2] == 5
+    assert vec[i16]([6, -8])[-2] == 6
+    assert vec[u8]([0, 123, 255])[-2] == 123
+    assert vec[float]([1.5, -3.5])[-2] == 1.5
+    assert vec[bool]([False, True])[-2] == False
+
+def test_append() -> None:
+    assert append(vec[i32](), 123) == vec[i32]([123])
+    assert append(vec[i16](), 123) == vec[i16]([123])
+    assert append(vec[u8](), 123) == vec[u8]([123])
+    assert append(vec[float](), 123.5) == vec[float]([123.5])
+    assert append(vec[bool](), True) == vec[bool]([True])
+
+def test_unbox() -> None:
+    v: vec[i64]
+
+    a = cast(Any, vec[i32]([1, 2]))
+    v_i32: vec[i32] = a
+    assert v_i32 == vec[i32]([1, 2])
+    with assertRaises(TypeError):
+        v = a
+
+    a = cast(Any, vec[i16]([1, 2]))
+    v_i16: vec[i16] = a
+    assert v_i16 == vec[i16]([1, 2])
+    with assertRaises(TypeError):
+        v = a
+
+    a = cast(Any, vec[u8]([1, 2]))
+    v_u8: vec[u8] = a
+    assert v_u8 == vec[u8]([1, 2])
+    with assertRaises(TypeError):
+        v = a
+
+    a = cast(Any, vec[float]([1, 2]))
+    v_float: vec[float] = a
+    assert v_float == vec[float]([1, 2])
+    with assertRaises(TypeError):
+        v = a
+
+    a = cast(Any, vec[bool]([True, False]))
+    v_bool: vec[bool] = a
+    assert v_bool == vec[bool]([True, False])
+    with assertRaises(TypeError):
+        v = a
+
+def test_set_item() -> None:
+    v = vec[i32]([5, -12])
+    v[1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[i16]([5, -12])
+    v[1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[u8]([5, 237])
+    v[1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[float]([1.5, -3.5])
+    v[1] = 5.5
+    assert v[0] == 1.5 and v[1] == 5.5
+
+    v = vec[bool]([True, False])
+    v[1] = True
+    assert v[0] and v[1]
+
+def test_set_item_negative() -> None:
+    v = vec[i32]([5, -12])
+    v[-1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[i16]([5, -12])
+    v[-1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[u8]([5, 237])
+    v[-1] = 55
+    assert v[0] == 5 and v[1] == 55
+
+    v = vec[float]([1.5, -3.5])
+    v[-1] = 5.5
+    assert v[0] == 1.5 and v[1] == 5.5
+
+    v = vec[bool]([True, False])
+    v[-1] = True
+    assert v[0] and v[1]
+
+def test_for_loop() -> None:
+    a: Any = []
+    for x in vec[float]([1.5, -3.5]):
+        a.append(x)
+    assert a == [1.5, -3.5]
+
+    a = []
+    for x in vec[bool]([True, False, False, True]):
+        a.append(x)
+    assert a == [True, False, False, True]
+
+    a = []
+    for x in vec[u8]([0, 5, 237, 255]):
+        a.append(x)
+    assert a == [0, 5, 237, 255]
+
+def test_comprehension() -> None:
+    v = vec[i32]([x + 1 for x in [1, 4, -5]])
+    assert list(v) == [2, 5, -4]
+
+    v = vec[float]([x + 1.5 for x in range(4)])
+    assert list(v) == [1.5, 2.5, 3.5, 4.5]
+
+def test_nested_basics() -> None:
+    v = vec[vec[i32]]([vec[i32]([5, 6]),
+                       vec[i32]([-12])])
+    assert str(v) == "vec[vec[i32]]([[5, 6], [-12]])"
+    assert v[0][1] == 6
+    assert v[1][0] == -12
+
+    v = vec[vec[i16]]([vec[i16]([5, 6]),
+                       vec[i16]([-12])])
+    assert str(v) == "vec[vec[i16]]([[5, 6], [-12]])"
+    assert v[0][1] == 6
+    assert v[1][0] == -12
+
+    v = vec[vec[u8]]([vec[u8]([5, 6]),
+                      vec[u8]([237])])
+    assert str(v) == "vec[vec[u8]]([[5, 6], [237]])"
+    assert v[0][1] == 6
+    assert v[1][0] == 237
+
+    v = vec[vec[float]]([vec[float]([1.5, -3.5]),
+                         vec[float]([3.0])])
+    assert str(v) == "vec[vec[float]]([[1.5, -3.5], [3.0]])"
+    assert v[0][1] == -3.5
+    assert v[1][0] == 3.0
+
+    v = vec[vec[bool]]([vec[bool]([False, True]),
+                        vec[bool]([False])])
+    assert str(v) == "vec[vec[bool]]([[False, True], [False]])"
+    assert v[0][1] == True
+    assert v[1][0] == False
+
+def test_nested_unbox() -> None:
+    vv: vec[vec[i64]]
+
+    a = cast(Any, vec[vec[i32]]([vec[i32]([5])]))
+    v_i32: vec[vec[i32]] = a
+    assert str(v_i32) == "vec[vec[i32]]([[5]])"
+    with assertRaises(TypeError):
+        vv = a
+
+    a = cast(Any, vec[vec[i16]]([vec[i16]([5])]))
+    v_i16: vec[vec[i16]] = a
+    with assertRaises(TypeError):
+        vv = a
+
+    a = cast(Any, vec[vec[u8]]([vec[u8]([5])]))
+    v_u8: vec[vec[u8]] = a
+    with assertRaises(TypeError):
+        vv = a
+
+    a = cast(Any, vec[vec[float]]([vec[float]([5])]))
+    v_float: vec[vec[float]] = a
+    with assertRaises(TypeError):
+        vv = a
+
+    a = cast(Any, vec[vec[bool]]([vec[bool]([True])]))
+    v_bool: vec[vec[bool]] = a
+    with assertRaises(TypeError):
+        vv = a
+
+def test_nested_misc() -> None:
+    v = vec[vec[float]]()
+    assert len(v) == 0
+    v = append(v, vec[float]([1.5]))
+    assert len(v) == 1
+    for x in v:
+        assert x == vec[float]([1.5])
+    vv, x = pop(v)
+    assert vv == vec[vec[float]]()
+    assert x == vec[float]([1.5])
+    v[0] = vec[float]([-2.5])
+    assert v[0] == vec[float]([-2.5])
+    v[0][0] = 3.5
+    assert v[0] == vec[float]([3.5])
+    assert v[:5] == vec[vec[float]]([vec[float]([3.5])])
diff --git a/mypyc/test-data/run-vecs-nested.test b/mypyc/test-data/run-vecs-nested.test
new file mode 100644
index 000000000000..b20100644aff
--- /dev/null
+++ b/mypyc/test-data/run-vecs-nested.test
@@ -0,0 +1,468 @@
+[case testVecNestedBasicOps_librt_experimental]
+from typing import Final, Any, Iterable, Optional, Tuple
+import sys
+
+from mypy_extensions import i64
+from librt.vecs import vec, append, remove, pop
+
+from testutil import assertRaises
+
+def test_construct_empty_nested() -> None:
+    v = vec[vec[str]]()
+    assert len(v) == 0
+    v2 = vec[vec[vec[vec[vec[str]]]]]()
+    assert len(v2) == 0
+    v3 = vec[vec[i64]]()
+    assert len(v3) == 0
+
+def test_construct_empty_nested_optional() -> None:
+    v = vec[vec[Optional[str]]]()
+    assert len(v) == 0
+
+def test_construct_from_initializer_nested() -> None:
+    v = vec[vec[str]]([vec[str](['xyz', 'a'])])
+    assert len(v) == 1
+    assert len(v[0]) == 2
+    assert v[0][0] == 'xyz'
+    assert v[0][1] == 'a'
+
+def test_repr() -> None:
+    assert str(vec[vec[str]]()) == "vec[vec[str]]([])"
+    assert str(vec[vec[Optional[str]]]()) == "vec[vec[str | None]]([])"
+    if sys.version_info[1] >= 10:
+        assert str(vec[vec[str | None]]()) == "vec[vec[str | None]]([])"
+
+def test_append_nested() -> None:
+    v = vec[vec[str]]()
+    vv = append(vec[str](), '1')
+    v = append(v, vv)
+    assert str(v) == "vec[vec[str]]([['1']])"
+    for n in range(2, 10):
+        vv = append(vec[str](), str(n))
+        v = append(v, vv)
+    assert str(v) == (
+        "vec[vec[str]]([['1'], ['2'], ['3'], ['4'], ['5'], ['6'], ['7'], ['8'], ['9']])"
+    )
+
+def test_append_i64() -> None:
+    v = vec[vec[i64]]()
+    vv = append(vec[i64](), 1)
+    v = append(v, vv)
+    assert str(v) == "vec[vec[i64]]([[1]])"
+    for n in range(2, 10):
+        vv = append(vec[i64](), n)
+        v = append(v, vv)
+    assert str(v) == (
+        "vec[vec[i64]]([[1], [2], [3], [4], [5], [6], [7], [8], [9]])"
+    )
+
+def test_append_nested_optional() -> None:
+    v = vec[vec[Optional[str]]]()
+    v = append(v, vec[Optional[str]]())
+    v[0] = append(v[0], None)
+    v[0] = append(v[0], 'x')
+    assert str(v) == "vec[vec[str | None]]([[None, 'x']])"
+
+def test_get_item() -> None:
+    v = append(vec[vec[str]](), append(vec[str](), 'x'))
+    vv = v[0]
+    assert vv == vec[str](['x'])
+    v = append(v, append(vec[str](), 'y'))
+    assert repr(v[0]) == "vec[str](['x'])"
+    assert repr(v[1]) == "vec[str](['y'])"
+
+def test_get_item_error() -> None:
+    v = append(vec[vec[str]](), vec[str](['1']))
+    v = append(v, vec[str](['3']))
+    with assertRaises(IndexError):
+        v[2]
+    with assertRaises(IndexError):
+        v[-3]
+
+def test_len() -> None:
+    v = vec[vec[str]]()
+    assert len(v) == 0
+    v = append(v, vec[str](['1']))
+    assert len(v) == 1
+    v = append(v, vec[str]())
+    assert len(v) == 2
+    for i in range(100):
+        v = append(v, vec[str](['i']))
+        assert len(v) == i + 3
+
+def test_set_item_error_nested() -> None:
+    v = append(vec[vec[str]](), vec[str]())
+    v = append(v, vec[str]())
+    v = append(v, vec[str]())
+    with assertRaises(IndexError):
+        v[3] = vec[str]()
+    with assertRaises(IndexError):
+        v[-4] = vec[str]()
+    assert repr(v[0]) == 'vec[str]([])'
+
+def test_equality() -> None:
+    assert vec[vec[str]]() == vec[vec[str]]()
+    assert vec[vec[str]]([vec[str](['x'])]) == vec[vec[str]]([vec[str](['x'])])
+    assert vec[vec[str]]([vec[str](['x'])]) != vec[vec[str]]()
+    assert vec[vec[str]]([vec[str](['x'])]) != vec[vec[str]]([vec[str](['y'])])
+
+def test_equality_different_types() -> None:
+    a = vec[vec[str]]()
+    b = vec[str]()
+    assert a == a
+    assert b == b
+    assert b != a
+    assert a != b
+
+    c = vec[vec[vec[str]]]()
+    assert c != a
+    assert a != c
+    assert c == c
+
+    d = vec[vec[Optional[str]]]()
+    assert d != a
+    assert a != d
+    assert d == d
+
+    assert vec[vec[str]]() != vec[vec[bytes]]()
+    assert vec[vec[str]]() != vec[vec[i64]]()
+
+def test_slicing() -> None:
+    v = vec[vec[str]](vec[str]([str(i)]) for i in range(5))
+    assert v[1:4] == vec[vec[str]]([v[1], v[2], v[3]])
+    assert v[2:-1] == vec[vec[str]]([v[2], v[3]])
+    assert v[-2:-1] == vec[vec[str]]([v[3]])
+    assert v[1:] == vec[vec[str]]([v[1], v[2], v[3], v[4]])
+    assert v[:-1] == vec[vec[str]]([v[0], v[1], v[2], v[3]])
+    assert v[:] == v
+    assert v[:] is not v
+    assert v[0:5] ==v
+    assert v[0:5] is not v
+    assert v[2:100] == vec[vec[str]]([v[2], v[3], v[4]])
+    assert v[-100:2] == vec[vec[str]]([v[0], v[1]])
+    assert v[5:100] == vec[vec[str]]([])
+    assert v[50:100] == vec[vec[str]]([])
+    assert v[-100:-50] == vec[vec[str]]([])
+
+def test_slicing_with_step() -> None:
+    v = vec[vec[str]](vec[str]([str(i)]) for i in range(10))
+    assert v[1:5:2] == vec[vec[str]]([v[1], v[3]])
+    assert v[1:6:2] == vec[vec[str]]([v[1], v[3], v[5]])
+    assert v[5:1:-2] == vec[vec[str]]([v[5], v[3]])
+    assert v[6:1:-2] == vec[vec[str]]([v[6], v[4], v[2]])
+    v = vec[vec[str]](vec[str]([str(i)]) for i in range(5))
+    assert v[::-1] == vec[vec[str]]([v[4], v[3], v[2], v[1], v[0]])
+    with assertRaises(ValueError):
+        v[1:3:0]
+
+def test_slicing_with_different_item_types() -> None:
+    v = vec[vec[i64]]([vec[i64]([11]), vec[i64]([22])])
+    assert v[1:] == vec[vec[i64]]([vec[i64]([22])])
+
+def test_remove() -> None:
+    a = ['4x', '7x', '9x']
+    vv = [vec[str]([s]) for s in a]
+    for i, s in enumerate(a):
+        v = vec[vec[str]](vv)
+        v = remove(v, vv[i])
+        assert v == vec[vec[str]]([j for j in vv if j != vv[i]])
+        v = vec[vec[str]](vv)
+        # Make sure we have a different object identity
+        v = remove(v, vec[str]([a[i]]))
+        assert v == vec[vec[str]]([j for j in vv if j != vv[i]])
+    v = vec[vec[str]](vv)
+    v = remove(v, vv[0])
+    v = remove(v, vv[1])
+    v = remove(v, vv[2])
+    assert v == vec[vec[str]]()
+    with assertRaises(ValueError):
+        remove(v, vec[str](['4']))
+    v = append(v, vec[str](['5']))
+    with assertRaises(ValueError):
+        remove(v, vec[str](['7']))
+    v = remove(v, vec[str](['5']))
+    assert len(v) == 0
+    v = v0 = vec[vec[str]]([vec[str](['x']) for _ in range(3)])
+    v = remove(v, vec[str](['x']))
+    assert v == v0[1:]
+    v = remove(v, vec[str](['x']))
+    assert v == v0[2:]
+    v = remove(v, vec[str](['x']))
+    assert v == vec[vec[str]]()
+    vb: Any = vec[bytes]([b'x'])
+    with assertRaises(TypeError):
+        remove(v, vb)
+
+def test_pop_last() -> None:
+    v = vec[vec[str]]([vec[str](['4']), vec[str](['6']), vec[str](['9'])])
+    v, item = pop(v)
+    assert item == vec[str](['9'])
+    assert v == vec[vec[str]]([vec[str](['4']), vec[str](['6'])])
+    v, item = pop(v)
+    assert item == vec[str](['6'])
+    assert v == vec[vec[str]]([vec[str](['4'])])
+    v, item = pop(v)
+    assert item == vec[str](['4'])
+    assert v == vec[vec[str]]()
+    with assertRaises(IndexError):
+        pop(v)
+
+def test_pop_index() -> None:
+    v = vec[vec[str]](vec[str]([s]) for s in ['4', '7', '9', '15', '22'])
+    v, item = pop(v, 0)
+    assert item == vec[str](['4'])
+    assert v == vec[vec[str]](vec[str]([s]) for s in ['7', '9', '15', '22'])
+    v, item = pop(v, -1)
+    assert item == vec[str](['22'])
+    assert v == vec[vec[str]](vec[str]([s]) for s in ['7', '9', '15'])
+    v, item = pop(v, 1)
+    assert item == vec[str](['9'])
+    assert v == vec[vec[str]](vec[str]([s]) for s in ['7', '15'])
+
+    with assertRaises(IndexError):
+        pop(v, 2)
+
+    with assertRaises(IndexError):
+        pop(v, -3)
+
+    v, item = pop(v, -2)
+    assert item == vec[str](['7'])
+    assert v == vec[vec[str]]([vec[str](['15'])])
+    v, item = pop(v, 0)
+    assert item == vec[str](['15'])
+    assert v == vec[vec[str]]()
+
+def test_doubly_nested_operations() -> None:
+    a = vec[vec[str]]([vec[str](["x"])])
+    b = vec[vec[str]]([vec[str]()])
+    v = vec[vec[vec[str]]]()
+
+    # append
+    v = append(v, a)
+    assert repr(v) == "vec[vec[vec[str]]]([[['x']]])"
+    v = append(v, b)
+    assert len(v) == 2
+
+    # get item
+    assert v[0] == a
+    assert v[1] == b
+
+    # set item
+    v[0] = b
+    assert v[0] == b
+    v[0] = a
+    with assertRaises(IndexError):
+        v[2 + int()]
+    with assertRaises(IndexError):
+        v[2 + int()] = a
+
+    # slicing
+    vv = v[:1]
+    assert len(vv) == 1
+    assert vv[0] == a
+    vv = v[1:]
+    assert len(vv) == 1
+    assert vv[0] == b
+
+    # remove
+    v = remove(v, a)
+    assert len(v) == 1
+    assert v[0] == b
+    v = remove(v, b)
+    assert len(v) == 0
+
+    # pop last
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v)
+    assert len(v) == 1
+    assert v[0] == a
+    assert x == b
+    v, x = pop(v)
+    assert len(v) == 0
+    assert x == a
+    with assertRaises(IndexError):
+        pop(v)
+
+    # pop index
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v, 0)
+    assert len(v) == 1
+    assert v[0] == b
+    assert x == a
+
+    # TODO: box/unbox
+
+def test_vec_i64_nested_operations() -> None:
+    a = vec[i64]([11])
+    b = vec[i64]()
+    v = vec[vec[i64]]()
+
+    # append
+    v = append(v, a)
+    assert repr(v) == "vec[vec[i64]]([[11]])"
+    v = append(v, b)
+    assert len(v) == 2
+
+    # get item
+    assert v[0] == a
+    assert v[1] == b
+
+    # set item
+    v[0] = b
+    assert v[0] == b
+    v[0] = a
+    with assertRaises(IndexError):
+        v[2 + int()]
+    with assertRaises(IndexError):
+        v[2 + int()] = a
+
+    # slicing
+    vv = v[:1]
+    assert len(vv) == 1
+    assert vv[0] == a
+    vv = v[1:]
+    assert len(vv) == 1
+    assert vv[0] == b
+
+    # remove
+    v = remove(v, a)
+    assert len(v) == 1
+    assert v[0] == b
+    v = remove(v, b)
+    assert len(v) == 0
+
+    # pop last
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v)
+    assert len(v) == 1
+    assert v[0] == a
+    assert x == b
+    v, x = pop(v)
+    assert len(v) == 0
+    assert x == a
+    with assertRaises(IndexError):
+        pop(v)
+
+    # pop index
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v, 0)
+    assert len(v) == 1
+    assert v[0] == b
+    assert x == a
+
+    # TODO: box/unbox
+
+def test_doubly_nested_vec_i64_operations() -> None:
+    a = vec[vec[i64]]([vec[i64]([11])])
+    b = vec[vec[i64]]([vec[i64]()])
+    v = vec[vec[vec[i64]]]()
+
+    # append
+    v = append(v, a)
+    assert repr(v) == "vec[vec[vec[i64]]]([[[11]]])"
+    v = append(v, b)
+    assert len(v) == 2
+
+    # get item
+    assert v[0] == a
+    assert v[1] == b
+
+    # set item
+    v[0] = b
+    assert v[0] == b
+    v[0] = a
+    with assertRaises(IndexError):
+        v[2 + int()]
+    with assertRaises(IndexError):
+        v[2 + int()] = a
+
+    # slicing
+    vv = v[:1]
+    assert len(vv) == 1
+    assert vv[0] == a
+    vv = v[1:]
+    assert len(vv) == 1
+    assert vv[0] == b
+
+    # remove
+    v = remove(v, a)
+    assert len(v) == 1
+    assert v[0] == b
+    v = remove(v, b)
+    assert len(v) == 0
+
+    # pop last
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v)
+    assert len(v) == 1
+    assert v[0] == a
+    assert x == b
+    v, x = pop(v)
+    assert len(v) == 0
+    assert x == a
+    with assertRaises(IndexError):
+        pop(v)
+
+    # pop index
+    v = append(v, a)
+    v = append(v, b)
+    v, x = pop(v, 0)
+    assert len(v) == 1
+    assert v[0] == b
+    assert x == a
+
+    # TODO: box/unbox
+
+def f(x: vec[vec[str]]) -> None:
+    pass
+
+def test_wrapper_arg_check() -> None:
+    f_any: Any = f
+    with assertRaises(TypeError):
+        f_any(vec[str]())
+    with assertRaises(TypeError):
+        f_any(None)
+    with assertRaises(TypeError):
+        f_any([])
+
+v: Final = vec[vec[str]]([vec[str](["x"])])
+
+def test_final() -> None:
+    assert v == vec[vec[str]]([vec[str](["x"])])
+
+def fdefault(v: vec[vec[str]] = vec[vec[str]]()) -> vec[vec[str]]:
+    return v
+
+def test_default_arg() -> None:
+    assert fdefault() == vec[vec[str]]()
+    v = vec[vec[str]]([vec[str](["x"])])
+    assert fdefault(v) == v
+    f_any: Any = fdefault
+    assert f_any() == vec[vec[str]]()
+    assert f_any(v) == v
+
+def ftuple(b: bool) -> Tuple[vec[vec[str]], vec[vec[str]]]:
+    if b:
+        raise RuntimeError()
+    return vec[vec[str]]([vec[str]()]), vec[vec[str]]()
+
+def test_tuple() -> None:
+    t = ftuple(False)
+    assert len(t) == 2
+    assert t[0] == vec[vec[str]]([vec[str]()])
+    assert t[1] == vec[vec[str]]()
+    a, b = t
+    assert a == t[0]
+    assert b == t[1]
+    with assertRaises(RuntimeError):
+        ftuple(True)
+    f_any: Any = ftuple
+    t2 = f_any(False)
+    assert t == t2
+    with assertRaises(RuntimeError):
+        f_any(True)
diff --git a/mypyc/test-data/run-vecs-t.test b/mypyc/test-data/run-vecs-t.test
new file mode 100644
index 000000000000..b9c6a6b0710c
--- /dev/null
+++ b/mypyc/test-data/run-vecs-t.test
@@ -0,0 +1,406 @@
+-- Test cases for vec[t] where t is a boxed, non-vec type (PyObject *).
+-- Also tests for vec[t | None], which uses the same representation.
+
+[case testVecTBasicOps_librt_experimental]
+from typing import Final, Any, Iterable, Optional, Tuple
+
+from mypy_extensions import i64
+from librt.vecs import vec, append, remove, pop
+
+from testutil import assertRaises
+
+def test_create_empty() -> None:
+    v = vec[str]()
+    assert len(v) == 0
+    v2 = vec[Optional[str]]()
+    assert len(v2) == 0
+
+def test_create_from_list_and_get_item() -> None:
+    v = vec[str]([])
+    assert len(v) == 0
+
+    v = vec[str](["xyz", "0" + str(), str(), "foo"])
+    assert len(v) == 4
+    assert v[0] == "xyz"
+    assert v[1] == "0"
+    assert v[2] == ""
+    assert v[3] == "foo"
+
+    v = vec[str](["1", "2", "3", "4", "5", "6", "7", "8", "9"])
+    assert len(v) == 9
+    for i in range(i64(9)):
+        assert v[i] == str(i + 1)
+
+def test_create_optional_and_get_item() -> None:
+    v = vec[Optional[str]](["xyz", None])
+    assert len(v) == 2
+    assert v[0] == "xyz"
+    assert v[1] is None
+
+def test_append() -> None:
+    v = vec[str]()
+    v = append(v, str() + "3")
+    assert len(v) == 1
+    x = "xyz" + str()
+    v = append(v, x)
+    assert len(v) == 2
+    assert v[0] == "3"
+    assert v[1] == "xyz"
+    v = vec[str]()
+    for i in range(1024):
+        v = append(v, str(i * 3))
+    assert len(v) == 1024
+    for i in range(1024):
+        assert v[i] == str(i * 3)
+
+def test_get_item() -> None:
+    v = vec[str](["3", "4"])
+    x: i64 = int()
+    assert v[x] == "3"
+    assert v[int()] == "3"
+    x += 1
+    assert v[x] == "4"
+    assert v[int() + 1] == "4"
+    with assertRaises(IndexError):
+        v[x + 1]
+    with assertRaises(IndexError):
+        v[2]
+    with assertRaises(IndexError):
+        v[2**63 - 1]
+
+def test_set_item() -> None:
+    v = vec[str](["3", "4"])
+    v[0] = "0"
+    assert v[0] == "0"
+
+    x: i64 = int()
+
+    v[x] = "4"
+    assert v[x] == "4"
+
+    v[int()] = "5"
+    assert v[int()] == "5"
+
+    x += 1
+
+    v[x] = "-5"
+    assert v[x] == "-5"
+
+    v[1 + int()] = "xyz"
+    assert v[1] == "xyz"
+
+    with assertRaises(IndexError):
+        v[1 + x] = "6"
+    with assertRaises(IndexError):
+        v[2 + int()] = "6"
+
+def test_set_item_optional() -> None:
+    v = vec[Optional[str]](["3", None])
+    v[1] = str() + "a"
+    assert v[1] == "a"
+    v[0] = None
+    assert v[0] is None
+
+def test_box_and_unbox() -> None:
+    v = vec[str](["3", "5"])
+    o: Any = v
+    assert len(o) == 2
+    assert o[0] == "3"
+    assert o[1] == "5"
+    o[1] = "6"
+    v2: vec[str] = o
+    assert len(v2) == 2
+    assert v2[0] == "3"
+    assert v2[1] == "6"
+    o2: Any = None
+    with assertRaises(TypeError, "vec[str] object expected; got None"):
+        v2 = o2
+    o3: Any = vec[bytes]([])
+    with assertRaises(TypeError, "vec[str] object expected; got vec"):
+        v2 = o3
+
+def test_box_and_unbox_optional() -> None:
+    v = vec[Optional[str]](["3", "4"])
+    o: Any = v
+    o[0] = None
+    v = o
+    assert v == vec[Optional[str]]([None, "4"])
+
+    v2 = vec[str](["4"])
+    o2: Any = v2
+    o2[0] = "5"
+    v2 = o2
+    assert v2 == vec[str](["5"])
+
+    o3: Any = vec[str]()
+    # TODO: Use str | None instead union
+    with assertRaises(TypeError, "vec[str | None] object expected; got vec"):
+        v = o3
+
+    o4: Any = vec[Optional[str]](["3"])
+    with assertRaises(TypeError, "vec[str] object expected; got vec"):
+        v2 = o4
+
+def test_construct_from_list_multiply() -> None:
+    for i in range(50):
+        v = vec[str]([str(i + 1)] * i)
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == str(i + 1)
+    for i in range(50):
+        v = vec[str](i * [str(i - 1)])
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == str(i - 1)
+
+def test_construct_from_list_comprehension() -> None:
+    for i in range(50):
+        l = [i * i for i in range(i)]
+        v = vec[str]([str(n + 5) for n in l])
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == str(j * j + 5)
+
+def test_construct_from_iterable() -> None:
+    for i in range(50):
+        it: Iterable[str] = iter([str(i * i) for i in range(i)])
+        v = vec[str](it)
+        assert len(v) == i
+        for j in range(i):
+            assert v[j] == str(j * j)
+
+def test_equality() -> None:
+    v0 = vec[str]()
+    v0b = vec[str]()
+    v1 = vec[str](["1"])
+    v1b = vec[str](["3"])
+    assert v0 == v0
+    assert v1 == v1
+    assert v0 == v0b
+    assert v0 != v1
+    assert v1 != v1b
+    assert v1 != v0
+
+def test_equality_optional() -> None:
+    v = vec[str]()
+    vo = vec[Optional[str]]()
+    assert v != vo
+    assert vo == vo
+    vo2 = vec[Optional[str]](["x", None])
+    assert vo2 == vec[Optional[str]](["x", None])
+    assert vo2 != vec[Optional[str]](["x", "y"])
+    assert vo2 != vec[Optional[str]]([None, None])
+    assert vo2 != vec[Optional[str]](["x", None, None])
+
+def test_str_conversion() -> None:
+    v = vec[str]()
+    assert str(v) == "vec[str]([])"
+    assert repr(v) == "vec[str]([])"
+    v = vec[str](["126"])
+    assert str(v) == "vec[str](['126'])"
+    v = append(v, "5")
+    assert str(v) == "vec[str](['126', '5'])"
+    v = append(v, "xyz")
+    assert str(v) == "vec[str](['126', '5', 'xyz'])"
+    v2 = vec[Optional[str]]()
+    assert str(v2) == "vec[str | None]([])"
+    v2 = vec[Optional[str]](["x", None])
+    assert str(v2) == "vec[str | None](['x', None])"
+
+def test_for_loop() -> None:
+    for n in vec[str]():
+        assert False
+    a = []
+    for n in vec[str](["5"]):
+        a.append(n)
+    assert a == ["5"]
+    v = vec[str](["xyz", "9", "8"])
+    a = []
+    for n in v:
+        a.append(n)
+    assert a == ["xyz", "9", "8"]
+    assert len(v) == 3
+
+def test_contains() -> None:
+    v = vec[str]()
+    x = str()
+    assert x not in v
+    v = vec[str](["x"])
+    assert x + "x" in v
+    assert x not in v
+    v2 = vec[str](["xyz", "7", "9"])
+    assert x + "xyz" in v2
+    assert x + "7" in v2
+    assert x + "9" in v2
+    assert x not in v2
+    assert x + "x" not in v2
+
+def test_slicing() -> None:
+    v = vec[str]()
+    assert v[:] == vec[str]([])
+    assert v[1:] == vec[str]([])
+    assert v[:-5] == vec[str]([])
+    v = vec[str](["0", "1", "2", "3", "4"])
+    assert v[1:4] == vec[str](["1", "2", "3"])
+    assert v[2:-1] == vec[str](["2", "3"])
+    assert v[-2:-1] == vec[str](["3"])
+    assert v[1:] == vec[str](["1", "2", "3", "4"])
+    assert v[:-1] == vec[str](["0", "1", "2", "3"])
+    assert v[:] == v
+    assert v[:] is not v
+    assert v[5:] == vec[str]()
+    assert v[100:] == vec[str]()
+    assert v[0:5] ==v
+    assert v[0:5] is not v
+    assert v[2:100] == vec[str](["2", "3", "4"])
+    assert v[-100:2] == vec[str](["0", "1"])
+    assert v[5:100] == vec[str]([])
+    assert v[50:100] == vec[str]([])
+    assert v[-100:-50] == vec[str]([])
+
+def test_slicing_with_step() -> None:
+    v = vec[str](["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"])
+    assert v[1:5:2] == vec[str](["1", "3"])
+    assert v[1:6:2] == vec[str](["1", "3", "5"])
+    assert v[5:1:-2] == vec[str](["5", "3"])
+    assert v[6:1:-2] == vec[str](["6", "4", "2"])
+    v = vec[str](["0", "1", "2", "3", "4"])
+    assert v[::-1] == vec[str](["4", "3", "2", "1", "0"])
+    with assertRaises(ValueError):
+        v[1:3:0]
+
+def test_remove() -> None:
+    a = ["4", "7", "xyz"]
+    for i in a:
+        v = vec[str](a)
+        v = remove(v, i)
+        assert v == vec[str]([j for j in a if j != i])
+    v = vec[str](a)
+    v = remove(v, "4")
+    v = remove(v, "7")
+    v = remove(v, "xyz")
+    assert v == vec[str]()
+    with assertRaises(ValueError):
+        remove(v, "4")
+    v = append(v, "5")
+    with assertRaises(ValueError):
+        remove(v, "7")
+    v = remove(v, "5")
+    assert len(v) == 0
+    v = vec[str](["1", "1", "1"])
+    v = remove(v, "1")
+    assert v == vec[str](["1", "1"])
+    v = remove(v, "1")
+    assert v == vec[str](["1"])
+    v = remove(v, "1")
+    assert v == vec[str]()
+    f: Any = 1.1
+    with assertRaises(TypeError):
+        remove(v, f)
+    s: Any = None
+    with assertRaises(TypeError):
+        remove(v, s)
+
+def test_pop_last() -> None:
+    v = vec[str](["4", "7", "xyz"])
+    v, n = pop(v)
+    assert n == "xyz"
+    assert v == vec[str](["4", "7"])
+    v, n = pop(v)
+    assert n == "7"
+    assert v == vec[str](["4"])
+    v, n = pop(v)
+    assert n == "4"
+    assert v == vec[str]()
+    with assertRaises(IndexError):
+       pop(v)
+
+def test_pop_index() -> None:
+    v = vec[str](["4", "7", "9", "15", "22"])
+    v, n = pop(v, 0)
+    assert n == "4"
+    assert v == vec[str](["7", "9", "15", "22"])
+    v, n = pop(v, -1)
+    assert n == "22"
+    assert v == vec[str](["7", "9", "15"])
+    v, n = pop(v, 1)
+    assert n == "9"
+    assert v == vec[str](["7", "15"])
+
+    with assertRaises(IndexError):
+       pop(v, 2)
+
+    with assertRaises(IndexError):
+       pop(v, -3)
+
+    v, n = pop(v, -2)
+    assert n == "7"
+    assert v == vec[str](["15"])
+    v, n = pop(v, 0)
+    assert n == "15"
+    assert v == vec[str]()
+
+def test_pop_optional() -> None:
+    v = vec[Optional[str]](["x" + str(), None])
+    v, s = pop(v)
+    assert s is None
+    v, s = pop(v)
+    assert s == "x"
+    assert len(v) == 0
+    v = vec[Optional[str]](["x" + str(), None])
+    v, s = pop(v, 0)
+    assert s == "x"
+    v, s = pop(v, -1)
+    assert s is None
+
+def f(x: vec[str]) -> None:
+    pass
+
+def test_wrapper_arg_check() -> None:
+    f_any: Any = f
+    with assertRaises(TypeError):
+        f_any([])
+
+v: Final = vec[str](["x", "y"])
+
+def test_final() -> None:
+    assert v == vec[str](["x", "y"])
+
+def fdefault(v: vec[str] = vec[str](["x"])) -> vec[str]:
+    return v
+
+def test_default_arg() -> None:
+    assert fdefault() == vec[str](["x"])
+    assert fdefault(vec[str](["y"])) == vec[str](["y"])
+    f_any: Any = fdefault
+    assert f_any() == vec[str](["x"])
+    assert f_any(vec[str](["y"])) == vec[str](["y"])
+
+def ftuple(b: bool) -> Tuple[vec[str], vec[str]]:
+    if b:
+        raise RuntimeError()
+    return vec[str](["x"]), vec[str]()
+
+def test_tuple() -> None:
+    t = ftuple(False)
+    assert len(t) == 2
+    assert t[0] == vec[str](["x"])
+    assert t[1] == vec[str]()
+    a, b = t
+    assert a == t[0]
+    assert b == t[1]
+    with assertRaises(RuntimeError):
+        ftuple(True)
+    f_any: Any = ftuple
+    t2 = f_any(False)
+    assert t == t2
+    with assertRaises(RuntimeError):
+        f_any(True)
+
+def test_optional_item_new_syntax() -> None:
+    v = vec[str | None]()
+    assert len(v) == 0
+    assert str(v) == "vec[str | None]([])"
+    v = append(v, 'x')
+    v = append(v, None)
+    assert str(v) == "vec[str | None](['x', None])"

From 18edd4879d305bca59ba3eeaf31418e5059e3ec8 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Tue, 3 Feb 2026 16:05:33 +0000
Subject: [PATCH 03/13] Revert "Don't include run tests"

This reverts commit dc00bbd9659a842559dcf76d862aeedfe63405f1.
---
 mypyc/test/test_run.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index 56852f9ea3a9..7368bb93a1e5 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -83,6 +83,10 @@
     "run-vecs-misc-interp.test",
     "run-vecs-t-interp.test",
     "run-vecs-nested-interp.test",
+    "run-vecs-i64.test",
+    "run-vecs-misc.test",
+    "run-vecs-t.test",
+    "run-vecs-nested.test",
 ]
 
 if sys.version_info >= (3, 12):

From aa143755acdb967452873b52449ba544d3e640b3 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 12:16:12 +0000
Subject: [PATCH 04/13] Put C else in a C block as it can have multiple
 statements

---
 mypyc/codegen/emitclass.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index 387065d93bcf..fea628055111 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -1193,10 +1193,11 @@ def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> N
         emitter.emit_attr_bitmap_set("tmp", "self", rtype, cl, attr)
 
     if deletable:
-        emitter.emit_line("} else")
-        emitter.set_undefined_value(f"    self->{attr_field}", rtype)
+        emitter.emit_line("} else {")
+        emitter.set_undefined_value(f"self->{attr_field}", rtype)
         if rtype.error_overlap:
             emitter.emit_attr_bitmap_clear("self", rtype, cl, attr)
+        emitter.emit_line("}")
     emitter.emit_line("return 0;")
     emitter.emit_line("}")
 

From c237b41f00a61d377c6c383c76af10d169c7a8c1 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 12:18:20 +0000
Subject: [PATCH 05/13] Add defensive assert + comment

---
 mypyc/codegen/emit.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index f75f8d8a6bde..d1ab9f6c96c9 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -1118,7 +1118,10 @@ def emit_unbox(
 
     def vec_item_type_c(self, typ: RVec) -> str:
         item_type = typ.unwrap_item_type()
-        type_value = f"(size_t){self.type_c_ptr(item_type)}"
+        type_c_ptr = self.type_c_ptr(item_type)
+        # Can never be None, since we unwrapped the item type above
+        assert type_c_ptr is not None
+        type_value = f"(size_t){type_c_ptr}"
         if typ.is_optional():
             type_value = f"{type_value} | 1"
         return type_value

From c8ea454be6725ea9e45a0943dece539334429309 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:03:51 +0000
Subject: [PATCH 06/13] WIP

---
 mypyc/codegen/emit.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index d1ab9f6c96c9..f5d898f0d8ec 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -801,6 +801,7 @@ def emit_cast(
             assert not optional
             self.emit_tuple_cast(src, dest, typ, declare_dest, error, src_type)
         elif isinstance(typ, RVec):
+            assert False
             # TODO: Actually perform the type check, this is a no-op
             if declare_dest:
                 self.emit_line("PyObject *{};".format(dest))

From ac4ab8a3015e361905874a1dd143ff82649a1d88 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:23:08 +0000
Subject: [PATCH 07/13] WIP start work on cast to vec type

---
 mypyc/codegen/emit.py              | 23 +++++++++++++++++------
 mypyc/test-data/run-vecs-misc.test | 14 ++++++++++++++
 2 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index f5d898f0d8ec..f8e1a3da5708 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -801,14 +801,25 @@ def emit_cast(
             assert not optional
             self.emit_tuple_cast(src, dest, typ, declare_dest, error, src_type)
         elif isinstance(typ, RVec):
-            assert False
-            # TODO: Actually perform the type check, this is a no-op
             if declare_dest:
-                self.emit_line("PyObject *{};".format(dest))
-            self.emit_arg_check(src, dest, typ, "", optional)
-            self.emit_line("{} = {};".format(dest, src))
-            if optional:
+                self.emit_line(f"PyObject *{dest};")
+            # Check for specialized vec types (vec[i64], vec[i32], etc.)
+            api_name = vec_api_by_item_type.get(typ.item_type)
+            if api_name:
+                # Use boxed_type from API struct: Py_TYPE(src) == VecI64Api.boxed_type
+                check = f"(Py_TYPE({src}) == {api_name}.boxed_type)"
+                if likely:
+                    check = f"(likely{check})"
+                self.emit_arg_check(src, dest, typ, check, optional)
+                self.emit_lines(f"    {dest} = {src};", "else {")
+                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
                 self.emit_line("}")
+            else:
+                # Generic vec types (vec[T], nested vecs) - no runtime check for now
+                self.emit_arg_check(src, dest, typ, "", optional)
+                self.emit_line(f"{dest} = {src};")
+                if optional:
+                    self.emit_line("}")
         else:
             assert False, "Cast not implemented: %s" % typ
 
diff --git a/mypyc/test-data/run-vecs-misc.test b/mypyc/test-data/run-vecs-misc.test
index 0ef4021c4a51..5e8782a2da94 100644
--- a/mypyc/test-data/run-vecs-misc.test
+++ b/mypyc/test-data/run-vecs-misc.test
@@ -145,6 +145,20 @@ def test_comprehension() -> None:
     v = vec[float]([x + 1.5 for x in range(4)])
     assert list(v) == [1.5, 2.5, 3.5, 4.5]
 
+def len_union(x: vec[i64] | vec[i32]) -> int:
+    return len(x)
+
+def test_union_of_vecs() -> None:
+    assert len_union(vec[i64]()) == 0
+    assert len_union(vec[i64]([7, 8])) == 2
+    assert len_union(vec[i32]([7, 8, 9])) == 3
+    with assertRaises(TypeError):
+        a1: Any = vec[i16]()
+        len_union(a1)
+    with assertRaises(TypeError):
+        a2: Any = []
+        len_union(a2)
+
 def test_nested_basics() -> None:
     v = vec[vec[i32]]([vec[i32]([5, 6]),
                        vec[i32]([-12])])

From 21801089177dcf81abf8d34f6b34ab1b78e63f4e Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:35:35 +0000
Subject: [PATCH 08/13] WIP support more vec casts

---
 mypyc/codegen/emit.py             | 18 ++++++++++++++++--
 mypyc/test-data/run-vecs-i64.test |  2 +-
 mypyc/test-data/run-vecs-t.test   | 24 ++++++++++++++++++++++++
 mypyc/test/test_emitfunc.py       |  6 +++---
 4 files changed, 44 insertions(+), 6 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index f8e1a3da5708..e191bb2143ee 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -814,8 +814,22 @@ def emit_cast(
                 self.emit_lines(f"    {dest} = {src};", "else {")
                 self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
                 self.emit_line("}")
+            elif typ.depth() == 0:
+                # Generic vec types (vec[T], vec[T | None]) with reference type items.
+                # Check both the boxed type and the item type (with optional bit).
+                item_type_c = self.vec_item_type_c(typ)
+                check = (
+                    f"(Py_TYPE({src}) == VecTApi.boxed_type && "
+                    f"((VecTObject *){src})->vec.buf->item_type == {item_type_c})"
+                )
+                if likely:
+                    check = f"(likely{check})"
+                self.emit_arg_check(src, dest, typ, check, optional)
+                self.emit_lines(f"    {dest} = {src};", "else {")
+                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+                self.emit_line("}")
             else:
-                # Generic vec types (vec[T], nested vecs) - no runtime check for now
+                # Nested vec types - no runtime check for now
                 self.emit_arg_check(src, dest, typ, "", optional)
                 self.emit_line(f"{dest} = {src};")
                 if optional:
@@ -1135,7 +1149,7 @@ def vec_item_type_c(self, typ: RVec) -> str:
         assert type_c_ptr is not None
         type_value = f"(size_t){type_c_ptr}"
         if typ.is_optional():
-            type_value = f"{type_value} | 1"
+            type_value = f"({type_value} | 1)"
         return type_value
 
     def type_c_ptr(self, typ: RPrimitive | RInstance) -> str | None:
diff --git a/mypyc/test-data/run-vecs-i64.test b/mypyc/test-data/run-vecs-i64.test
index 326561d25a64..e07fff5a8875 100644
--- a/mypyc/test-data/run-vecs-i64.test
+++ b/mypyc/test-data/run-vecs-i64.test
@@ -225,7 +225,7 @@ def test_vec_union() -> None:
     with assertRaises(TypeError):
         check_union(a3, False)
     a4: Any = vec[i32]()
-    with assertRaises(TypeError, 'vec[i64] object expected; got vec[i32]'):
+    with assertRaises(TypeError, 'union[vec[i64], str] object expected; got vec[i32]'):
         check_union(a4, False)
 
 def test_construct_from_list_multiply() -> None:
diff --git a/mypyc/test-data/run-vecs-t.test b/mypyc/test-data/run-vecs-t.test
index b9c6a6b0710c..a2fd6457e6ae 100644
--- a/mypyc/test-data/run-vecs-t.test
+++ b/mypyc/test-data/run-vecs-t.test
@@ -404,3 +404,27 @@ def test_optional_item_new_syntax() -> None:
     v = append(v, 'x')
     v = append(v, None)
     assert str(v) == "vec[str | None](['x', None])"
+
+class Foo:
+    def __init__(self, s: str) -> None:
+        self.s = s
+
+def len_union(x: vec[str] | vec[Optional[Foo]]) -> int:
+    return len(x)
+
+def test_union_of_vecs() -> None:
+    assert len_union(vec[str]()) == 0
+    assert len_union(vec[str](["x", "y"])) == 2
+    assert len_union(vec[Optional[Foo]]([Foo("x"), None, Foo("y")])) == 3
+    with assertRaises(TypeError):
+        a1: Any = vec[Optional[str]]()
+        len_union(a1)
+    with assertRaises(TypeError):
+        a2: Any = []
+        len_union(a2)
+    with assertRaises(TypeError):
+        a3: Any = vec[bytes]()
+        len_union(a3)
+    with assertRaises(TypeError):
+        a4: Any = vec[Foo]()
+        len_union(a4)
diff --git a/mypyc/test/test_emitfunc.py b/mypyc/test/test_emitfunc.py
index 59ab4cb8a0e5..dc8f8b26c951 100644
--- a/mypyc/test/test_emitfunc.py
+++ b/mypyc/test/test_emitfunc.py
@@ -378,7 +378,7 @@ def test_box_vec(self) -> None:
             Box(self.vs), """cpy_r_r0 = VecTApi.box(cpy_r_vs, (size_t)&PyUnicode_Type);"""
         )
         self.assert_emit(
-            Box(self.vs_opt), """cpy_r_r0 = VecTApi.box(cpy_r_vs, (size_t)&PyUnicode_Type | 1);"""
+            Box(self.vs_opt), """cpy_r_r0 = VecTApi.box(cpy_r_vs, ((size_t)&PyUnicode_Type | 1));"""
         )
         self.assert_emit(Box(self.vvs), """cpy_r_r0 = VecNestedApi.box(cpy_r_vvs);""")
 
@@ -409,7 +409,7 @@ def test_unbox_vec(self) -> None:
         )
         self.assert_emit(
             Unbox(self.o, RVec(RUnion([str_rprimitive, none_rprimitive])), 55),
-            """cpy_r_r0 = VecTApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type | 1);
+            """cpy_r_r0 = VecTApi.unbox(cpy_r_o, ((size_t)&PyUnicode_Type | 1));
                if (VEC_IS_ERROR(cpy_r_r0)) {
                    CPy_TypeError("vec[str | None]", cpy_r_o); cpy_r_r0 = (VecT) { -1, NULL };
                }
@@ -435,7 +435,7 @@ def test_unbox_vec_nested(self) -> None:
         )
         self.assert_emit(
             Unbox(self.o, RVec(RVec(RUnion([str_rprimitive, none_rprimitive]))), 55),
-            """cpy_r_r0 = VecNestedApi.unbox(cpy_r_o, (size_t)&PyUnicode_Type | 1, 1);
+            """cpy_r_r0 = VecNestedApi.unbox(cpy_r_o, ((size_t)&PyUnicode_Type | 1), 1);
                if (VEC_IS_ERROR(cpy_r_r0)) {
                    CPy_TypeError("vec[vec[str | None]]", cpy_r_o); cpy_r_r0 = (VecNested) { -1, NULL };
                }

From 117c47551dfef8b215b435f5e2eb87ef8872ab0c Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:43:34 +0000
Subject: [PATCH 09/13] Add missing nested vec case for casts

---
 mypyc/codegen/emit.py                | 23 ++++++++++++++++-----
 mypyc/test-data/run-vecs-nested.test | 30 +++++++++++++++++++++++++++-
 2 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index e191bb2143ee..f289650809c7 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -829,11 +829,24 @@ def emit_cast(
                 self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
                 self.emit_line("}")
             else:
-                # Nested vec types - no runtime check for now
-                self.emit_arg_check(src, dest, typ, "", optional)
-                self.emit_line(f"{dest} = {src};")
-                if optional:
-                    self.emit_line("}")
+                # Nested vec types (vec[vec[...]]). Check boxed type, item type, and depth.
+                depth = typ.depth()
+                unwrapped = typ.unwrap_item_type()
+                if unwrapped in vec_item_type_tags:
+                    type_value = str(vec_item_type_tags[unwrapped])
+                else:
+                    type_value = self.vec_item_type_c(typ)
+                check = (
+                    f"(Py_TYPE({src}) == VecNestedApi.boxed_type && "
+                    f"((VecNestedObject *){src})->vec.buf->item_type == {type_value} && "
+                    f"((VecNestedObject *){src})->vec.buf->depth == {depth})"
+                )
+                if likely:
+                    check = f"(likely{check})"
+                self.emit_arg_check(src, dest, typ, check, optional)
+                self.emit_lines(f"    {dest} = {src};", "else {")
+                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+                self.emit_line("}")
         else:
             assert False, "Cast not implemented: %s" % typ
 
diff --git a/mypyc/test-data/run-vecs-nested.test b/mypyc/test-data/run-vecs-nested.test
index b20100644aff..a8c8032121e7 100644
--- a/mypyc/test-data/run-vecs-nested.test
+++ b/mypyc/test-data/run-vecs-nested.test
@@ -2,7 +2,7 @@
 from typing import Final, Any, Iterable, Optional, Tuple
 import sys
 
-from mypy_extensions import i64
+from mypy_extensions import i64, i32
 from librt.vecs import vec, append, remove, pop
 
 from testutil import assertRaises
@@ -466,3 +466,31 @@ def test_tuple() -> None:
     assert t == t2
     with assertRaises(RuntimeError):
         f_any(True)
+
+def len_union(x: vec[vec[i64]] | vec[vec[Optional[str]]]) -> int:
+    return len(x)
+
+def test_union_of_nested_vecs() -> None:
+    assert len_union(vec[vec[i64]]()) == 0
+    assert len_union(vec[vec[i64]]([vec[i64]([1, 2])])) == 1
+    assert len_union(vec[vec[Optional[str]]]([vec[Optional[str]](["x", None])])) == 1
+    # Wrong inner item type (i32 instead of i64)
+    with assertRaises(TypeError):
+        a1: Any = vec[vec[i32]]()
+        len_union(a1)
+    # Wrong inner item type (str instead of str | None)
+    with assertRaises(TypeError):
+        a2: Any = vec[vec[str]]()
+        len_union(a2)
+    # Not a nested vec
+    with assertRaises(TypeError):
+        a3: Any = vec[i64]()
+        len_union(a3)
+    # Plain list
+    with assertRaises(TypeError):
+        a4: Any = []
+        len_union(a4)
+    # Too deeply nested
+    with assertRaises(TypeError):
+        a5: Any = vec[vec[vec[i64]]]()
+        len_union(a5)

From 0f4ac43ab88e7aa5a07f652c526b44ab12ab9ff6 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:46:50 +0000
Subject: [PATCH 10/13] Refactor

---
 mypyc/codegen/emit.py | 35 +++++++++++------------------------
 1 file changed, 11 insertions(+), 24 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index f289650809c7..e313c9231564 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -803,34 +803,21 @@ def emit_cast(
         elif isinstance(typ, RVec):
             if declare_dest:
                 self.emit_line(f"PyObject *{dest};")
-            # Check for specialized vec types (vec[i64], vec[i32], etc.)
+            # Build type check expression based on vec kind
             api_name = vec_api_by_item_type.get(typ.item_type)
+            depth = typ.depth()
             if api_name:
-                # Use boxed_type from API struct: Py_TYPE(src) == VecI64Api.boxed_type
+                # Specialized vec types (vec[i64], vec[i32], etc.)
                 check = f"(Py_TYPE({src}) == {api_name}.boxed_type)"
-                if likely:
-                    check = f"(likely{check})"
-                self.emit_arg_check(src, dest, typ, check, optional)
-                self.emit_lines(f"    {dest} = {src};", "else {")
-                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
-                self.emit_line("}")
-            elif typ.depth() == 0:
-                # Generic vec types (vec[T], vec[T | None]) with reference type items.
-                # Check both the boxed type and the item type (with optional bit).
+            elif depth == 0:
+                # Generic vec types (vec[T], vec[T | None]) with reference type items
                 item_type_c = self.vec_item_type_c(typ)
                 check = (
                     f"(Py_TYPE({src}) == VecTApi.boxed_type && "
                     f"((VecTObject *){src})->vec.buf->item_type == {item_type_c})"
                 )
-                if likely:
-                    check = f"(likely{check})"
-                self.emit_arg_check(src, dest, typ, check, optional)
-                self.emit_lines(f"    {dest} = {src};", "else {")
-                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
-                self.emit_line("}")
             else:
                 # Nested vec types (vec[vec[...]]). Check boxed type, item type, and depth.
-                depth = typ.depth()
                 unwrapped = typ.unwrap_item_type()
                 if unwrapped in vec_item_type_tags:
                     type_value = str(vec_item_type_tags[unwrapped])
@@ -841,12 +828,12 @@ def emit_cast(
                     f"((VecNestedObject *){src})->vec.buf->item_type == {type_value} && "
                     f"((VecNestedObject *){src})->vec.buf->depth == {depth})"
                 )
-                if likely:
-                    check = f"(likely{check})"
-                self.emit_arg_check(src, dest, typ, check, optional)
-                self.emit_lines(f"    {dest} = {src};", "else {")
-                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
-                self.emit_line("}")
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check, optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
         else:
             assert False, "Cast not implemented: %s" % typ
 

From 3209a6b747e1b3e6fb813db2237d52cb14a6d881 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Wed, 4 Feb 2026 16:50:46 +0000
Subject: [PATCH 11/13] Lint

---
 mypyc/test/test_emitfunc.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/mypyc/test/test_emitfunc.py b/mypyc/test/test_emitfunc.py
index dc8f8b26c951..ebb200ed4365 100644
--- a/mypyc/test/test_emitfunc.py
+++ b/mypyc/test/test_emitfunc.py
@@ -378,7 +378,8 @@ def test_box_vec(self) -> None:
             Box(self.vs), """cpy_r_r0 = VecTApi.box(cpy_r_vs, (size_t)&PyUnicode_Type);"""
         )
         self.assert_emit(
-            Box(self.vs_opt), """cpy_r_r0 = VecTApi.box(cpy_r_vs, ((size_t)&PyUnicode_Type | 1));"""
+            Box(self.vs_opt),
+            """cpy_r_r0 = VecTApi.box(cpy_r_vs, ((size_t)&PyUnicode_Type | 1));""",
         )
         self.assert_emit(Box(self.vvs), """cpy_r_r0 = VecNestedApi.box(cpy_r_vvs);""")
 

From ed4bbf1ea72599c0b58937fec080a19d2dad730a Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Thu, 5 Feb 2026 10:49:00 +0000
Subject: [PATCH 12/13] Address feedback

---
 mypyc/codegen/emitmodule.py        | 2 +-
 mypyc/test-data/run-vecs-i64.test  | 1 +
 mypyc/test-data/run-vecs-misc.test | 2 ++
 mypyc/test-data/run-vecs-t.test    | 1 -
 4 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index 554379b8848a..c1e76aa6df66 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -641,7 +641,7 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
         if any(LIBRT_TIME in mod.dependencies for mod in self.modules.values()):
             ext_declarations.emit_line("#include <time/librt_time.h>")
         if any(LIBRT_VECS in mod.dependencies for mod in self.modules.values()):
-            ext_declarations.emit_line('#include "vecs/librt_vecs.h"')
+            ext_declarations.emit_line('#include <vecs/librt_vecs.h>')
         # Include headers for conditional source files
         source_deps = collect_source_dependencies(self.modules)
         for source_dep in sorted(source_deps, key=lambda d: d.path):
diff --git a/mypyc/test-data/run-vecs-i64.test b/mypyc/test-data/run-vecs-i64.test
index e07fff5a8875..1c19bfb11e76 100644
--- a/mypyc/test-data/run-vecs-i64.test
+++ b/mypyc/test-data/run-vecs-i64.test
@@ -167,6 +167,7 @@ def check_opt(x: vec[i64] | None, is_none: bool) -> None:
     if is_none:
         assert x is None
     else:
+        # If statements ensure type narrowing doesn't leak between blocks
         if int() + 1:
             assert x is not None
             assert len(x) == 1
diff --git a/mypyc/test-data/run-vecs-misc.test b/mypyc/test-data/run-vecs-misc.test
index 5e8782a2da94..3a55c7fc4f3e 100644
--- a/mypyc/test-data/run-vecs-misc.test
+++ b/mypyc/test-data/run-vecs-misc.test
@@ -229,6 +229,8 @@ def test_nested_misc() -> None:
     vv, x = pop(v)
     assert vv == vec[vec[float]]()
     assert x == vec[float]([1.5])
+
+    # Since pop doesn't change the length of v, the following should work
     v[0] = vec[float]([-2.5])
     assert v[0] == vec[float]([-2.5])
     v[0][0] = 3.5
diff --git a/mypyc/test-data/run-vecs-t.test b/mypyc/test-data/run-vecs-t.test
index a2fd6457e6ae..153428148518 100644
--- a/mypyc/test-data/run-vecs-t.test
+++ b/mypyc/test-data/run-vecs-t.test
@@ -133,7 +133,6 @@ def test_box_and_unbox_optional() -> None:
     assert v2 == vec[str](["5"])
 
     o3: Any = vec[str]()
-    # TODO: Use str | None instead union
     with assertRaises(TypeError, "vec[str | None] object expected; got vec"):
         v = o3
 

From 055b7f03190ac3784d787cf6d1357ad4dbfaff06 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 5 Feb 2026 10:51:13 +0000
Subject: [PATCH 13/13] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 mypyc/codegen/emitmodule.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index c1e76aa6df66..136cb166e9ff 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -641,7 +641,7 @@ def generate_c_for_modules(self) -> list[tuple[str, str]]:
         if any(LIBRT_TIME in mod.dependencies for mod in self.modules.values()):
             ext_declarations.emit_line("#include <time/librt_time.h>")
         if any(LIBRT_VECS in mod.dependencies for mod in self.modules.values()):
-            ext_declarations.emit_line('#include <vecs/librt_vecs.h>')
+            ext_declarations.emit_line("#include <vecs/librt_vecs.h>")
         # Include headers for conditional source files
         source_deps = collect_source_dependencies(self.modules)
         for source_dep in sorted(source_deps, key=lambda d: d.path):