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 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: 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 = v.items
    r7 = r5 * 16
    r8 = r6 + r7
    r9 = load_mem r8 :: vec[str]*
    keep_alive v
    return r9

[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 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: 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 = v.items
    r7 = r5 * 16
    r8 = r6 + r7
    r9 = load_mem r8 :: vec[i64]*
    keep_alive v
    return r9

[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 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: vec[i64]
    r10 :: native_int
    r11 :: bit
    r12 :: i64
    r13 :: bit
    r14 :: bool
    r15 :: i64
    r16 :: ptr
    r17 :: i64
    r18 :: ptr
    r19 :: 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 = v.items
    r7 = r5 * 16
    r8 = r6 + r7
    r9 = borrow load_mem r8 :: vec[i64]*
    r10 = r9.len
    r11 = n < r10 :: unsigned
    if r11 goto L9 else goto L6 :: bool
L6:
    r12 = n + r10
    r13 = r12 < r10 :: unsigned
    if r13 goto L8 else goto L7 :: bool
L7:
    r14 = raise IndexError
    unreachable
L8:
    r15 = r12
    goto L10
L9:
    r15 = n
L10:
    r16 = r9.items
    r17 = r15 * 8
    r18 = r16 + r17
    r19 = load_mem r18 :: i64*
    keep_alive v, r9
    return r19

[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 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: 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 = v.items
    r7 = r5 * 16
    r8 = r6 + r7
    r9 = load_mem r8 :: vec[vec[str]]*
    keep_alive v
    return r9

[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