mypyc/test-data/irbuild-vec-nested.test

-- Test cases for nested vecs

[case testVecNestedConvertToList]
from librt.vecs import vec
from mypy_extensions import i64

def to_list(v: vec[vec[i64]]) -> list[vec[i64]]:
    return list(v)
[out]
def to_list(v):
    v :: vec[vec[i64]]
    r0 :: object
    r1 :: list
L0:
    r0 = box(vec[vec[i64]], v)
    r1 = PySequence_List(r0)
    return r1

[case testVecNestedConvertToTuple]
from librt.vecs import vec
from mypy_extensions import i64

def to_tuple(v: vec[vec[i64]]) -> tuple[vec[i64], ...]:
    return tuple(v)
[out]
def to_tuple(v):
    v :: vec[vec[i64]]
    r0 :: object
    r1 :: tuple
L0:
    r0 = box(vec[vec[i64]], v)
    r1 = PySequence_Tuple(r0)
    return r1

[case testVecNestedConvertToSequenceEvaluatesArgOnce]
from librt.vecs import vec
from mypy_extensions import i64

def make() -> vec[vec[i64]]:
    return vec[vec[i64]]()

def to_list() -> list[vec[i64]]:
    return list(make())

def to_tuple() -> tuple[vec[i64], ...]:
    return tuple(make())
[out]
def make():
    r0 :: vec[vec[i64]]
L0:
    r0 = VecNestedApi.alloc(0, 0, 2, 1)
    return r0
def to_list():
    r0 :: vec[vec[i64]]
    r1 :: object
    r2 :: list
L0:
    r0 = make()
    r1 = box(vec[vec[i64]], r0)
    r2 = PySequence_List(r1)
    return r2
def to_tuple():
    r0 :: vec[vec[i64]]
    r1 :: object
    r2 :: tuple
L0:
    r0 = make()
    r1 = box(vec[vec[i64]], r0)
    r2 = PySequence_Tuple(r1)
    return r2

[case testVecNestedCreateEmpty]
from librt.vecs import vec, append
from mypy_extensions import i64

def f() -> vec[vec[str]]:
    return vec[vec[str]]()

def g() -> vec[vec[i64]]:
    return vec[vec[i64]]()
[out]
def f():
    r0 :: object
    r1 :: ptr
    r2 :: vec[vec[str]]
L0:
    r0 = load_address PyUnicode_Type
    r1 = r0
    r2 = VecNestedApi.alloc(0, 0, r1, 1)
    return r2
def g():
    r0 :: vec[vec[i64]]
L0:
    r0 = VecNestedApi.alloc(0, 0, 2, 1)
    return r0

[case testVecNestedAppend]
from librt.vecs import vec, append

def f(v: vec[vec[str]], vv: vec[str]) -> vec[vec[str]]:
    return append(v, vv)
[out]
def f(v, vv):
    v :: vec[vec[str]]
    vv :: vec[str]
    r0 :: native_int
    r1 :: ptr
    r2, r3 :: VecNestedBufItem{len:native_int, items:ptr}
    r4 :: vec[vec[str]]
L0:
    r0 = vv.len
    r1 = vv.items
    r2 = set_element undef VecNestedBufItem, len, r0
    r3 = set_element r2, items, r1
    r4 = VecNestedApi.append(v, r3)
    keep_alive vv
    return r4

[case testVecNestedVecI64Append]
from librt.vecs import vec, append
from mypy_extensions import i64

def f(v: vec[vec[i64]], vv: vec[i64]) -> vec[vec[i64]]:
    return append(v, vv)
[out]
def f(v, vv):
    v :: vec[vec[i64]]
    vv :: vec[i64]
    r0 :: native_int
    r1 :: ptr
    r2, r3 :: VecNestedBufItem{len:native_int, items:ptr}
    r4 :: vec[vec[i64]]
L0:
    r0 = vv.len
    r1 = vv.items
    r2 = set_element undef VecNestedBufItem, len, r0
    r3 = set_element r2, items, r1
    r4 = VecNestedApi.append(v, r3)
    keep_alive vv
    return r4

[case testVecNestedExtend]
from librt.vecs import vec, extend
from typing import Iterable

def f(v: vec[vec[str]], it: Iterable[vec[str]]) -> vec[vec[str]]:
    return extend(v, it)
[out]
def f(v, it):
    v :: vec[vec[str]]
    it :: object
    r0 :: vec[vec[str]]
L0:
    r0 = VecNestedApi.extend(v, it)
    return r0

[case testVecNestedExtendVec]
from librt.vecs import vec, extend

def f(v: vec[vec[str]], v2: vec[vec[str]]) -> vec[vec[str]]:
    return extend(v, v2)
[out]
def f(v, v2):
    v, v2, r0 :: vec[vec[str]]
L0:
    r0 = VecNestedApi.extend_vec(v, v2)
    return r0

[case testVecNestedLen_64bit]
from librt.vecs import vec
from mypy_extensions import i64
from typing import Optional

def f(v: vec[vec[str]]) -> i64:
    return len(v)

def g(v: vec[vec[i64]]) -> i64:
    return len(v)
[out]
def f(v):
    v :: vec[vec[str]]
    r0 :: native_int
L0:
    r0 = v.len
    return r0
def g(v):
    v :: vec[vec[i64]]
    r0 :: native_int
L0:
    r0 = v.len
    return r0

[case testVecNestedGetItem_64bit]
from librt.vecs import vec
from mypy_extensions import i64

def f(v: vec[vec[str]], n: i64) -> vec[str]:
    return v[n]
[out]
def f(v, n):
    v :: vec[vec[str]]
    n :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: vec[str]
L0:
    r0 = v.len
    r1 = n < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = n + r0
    r3 = r2 < r0 :: unsigned
    if r3 goto L3 else goto L2 :: bool
L2:
    r4 = raise IndexError
    unreachable
L3:
    r5 = r2
    goto L5
L4:
    r5 = n
L5:
    r6 = vec_get_item_unsafe[vec[str]] v, r5
    return r6

[case testVecNestedI64GetItem_64bit]
from librt.vecs import vec
from mypy_extensions import i64

def f(v: vec[vec[i64]], n: i64) -> vec[i64]:
    return v[n]
[out]
def f(v, n):
    v :: vec[vec[i64]]
    n :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: vec[i64]
L0:
    r0 = v.len
    r1 = n < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = n + r0
    r3 = r2 < r0 :: unsigned
    if r3 goto L3 else goto L2 :: bool
L2:
    r4 = raise IndexError
    unreachable
L3:
    r5 = r2
    goto L5
L4:
    r5 = n
L5:
    r6 = vec_get_item_unsafe[vec[i64]] v, r5
    return r6

[case testVecNestedI64GetItemWithBorrow_64bit]
from librt.vecs import vec
from mypy_extensions import i64

def f(v: vec[vec[i64]], n: i64) -> i64:
    return v[n][n]
[out]
def f(v, n):
    v :: vec[vec[i64]]
    n :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: vec[i64]
    r7 :: native_int
    r8 :: bit
    r9 :: i64
    r10 :: bit
    r11 :: bool
    r12, r13 :: i64
L0:
    r0 = v.len
    r1 = n < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = n + r0
    r3 = r2 < r0 :: unsigned
    if r3 goto L3 else goto L2 :: bool
L2:
    r4 = raise IndexError
    unreachable
L3:
    r5 = r2
    goto L5
L4:
    r5 = n
L5:
    r6 = vec_get_item_unsafe_borrow[vec[i64]] v, r5
    r7 = r6.len
    r8 = n < r7 :: unsigned
    if r8 goto L9 else goto L6 :: bool
L6:
    r9 = n + r7
    r10 = r9 < r7 :: unsigned
    if r10 goto L8 else goto L7 :: bool
L7:
    r11 = raise IndexError
    unreachable
L8:
    r12 = r9
    goto L10
L9:
    r12 = n
L10:
    r13 = vec_get_item_unsafe[i64] r6, r12
    keep_alive v, r5
    return r13

[case testVecNestedStrGetItemWithBorrow_64bit]
from librt.vecs import vec
from mypy_extensions import i64

class C:
    v: vec[vec[str]]

    def f(self, n: i64) -> str:
        # The intermediate vec is borrowed, but the result must be owned.
        return self.v[n][n]
[out]
def C.f(self, n):
    self :: __main__.C
    n :: i64
    r0 :: vec[vec[str]]
    r1 :: native_int
    r2 :: bit
    r3 :: i64
    r4 :: bit
    r5 :: bool
    r6 :: i64
    r7 :: vec[str]
    r8 :: native_int
    r9 :: bit
    r10 :: i64
    r11 :: bit
    r12 :: bool
    r13 :: i64
    r14 :: str
L0:
    r0 = borrow self.v
    r1 = r0.len
    r2 = n < r1 :: unsigned
    if r2 goto L4 else goto L1 :: bool
L1:
    r3 = n + r1
    r4 = r3 < r1 :: unsigned
    if r4 goto L3 else goto L2 :: bool
L2:
    r5 = raise IndexError
    unreachable
L3:
    r6 = r3
    goto L5
L4:
    r6 = n
L5:
    r7 = vec_get_item_unsafe_borrow[vec[str]] r0, r6
    r8 = r7.len
    r9 = n < r8 :: unsigned
    if r9 goto L9 else goto L6 :: bool
L6:
    r10 = n + r8
    r11 = r10 < r8 :: unsigned
    if r11 goto L8 else goto L7 :: bool
L7:
    r12 = raise IndexError
    unreachable
L8:
    r13 = r10
    goto L10
L9:
    r13 = n
L10:
    r14 = vec_get_item_unsafe[str] r7, r13
    keep_alive self, r0, r6
    return r14

[case testVecDoublyNestedGetItem_64bit]
from librt.vecs import vec
from mypy_extensions import i64

def f(v: vec[vec[vec[str]]], n: i64) -> vec[vec[str]]:
    return v[n]
[out]
def f(v, n):
    v :: vec[vec[vec[str]]]
    n :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: vec[vec[str]]
L0:
    r0 = v.len
    r1 = n < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = n + r0
    r3 = r2 < r0 :: unsigned
    if r3 goto L3 else goto L2 :: bool
L2:
    r4 = raise IndexError
    unreachable
L3:
    r5 = r2
    goto L5
L4:
    r5 = n
L5:
    r6 = vec_get_item_unsafe[vec[vec[str]]] v, r5
    return r6

[case testVecNestedCreateWithCap_64bit]
from librt.vecs import vec
from mypy_extensions import i64

def cap_str() -> vec[vec[str]]:
    return vec[vec[str]](capacity=5)

def cap_i64() -> vec[vec[i64]]:
    return vec[vec[i64]](capacity=5)

def cap_variable(n: i64) -> vec[vec[str]]:
    return vec[vec[str]](capacity=n)
[out]
def cap_str():
    r0 :: object
    r1 :: ptr
    r2 :: vec[vec[str]]
L0:
    r0 = load_address PyUnicode_Type
    r1 = r0
    r2 = VecNestedApi.alloc(0, 5, r1, 1)
    return r2
def cap_i64():
    r0 :: vec[vec[i64]]
L0:
    r0 = VecNestedApi.alloc(0, 5, 2, 1)
    return r0
def cap_variable(n):
    n :: i64
    r0 :: object
    r1 :: ptr
    r2 :: vec[vec[str]]
L0:
    r0 = load_address PyUnicode_Type
    r1 = r0
    r2 = VecNestedApi.alloc(0, n, r1, 1)
    return r2