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

-- 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 irbuild-vec-i64.test.

[case testVecMiscCreateEmpty]
from librt.vecs import vec

from mypy_extensions import i32, i16, u8

def create_float() -> vec[float]:
    return vec[float]()

def create_i32() -> vec[i32]:
    return vec[i32]()

def create_i16() -> vec[i16]:
    return vec[i16]()

def create_u8() -> vec[u8]:
    return vec[u8]()

def create_bool() -> vec[bool]:
    return vec[bool]()
[out]
def create_float():
    r0 :: vec[float]
L0:
    r0 = VecFloatApi.alloc(0, 0)
    return r0
def create_i32():
    r0 :: vec[i32]
L0:
    r0 = VecI32Api.alloc(0, 0)
    return r0
def create_i16():
    r0 :: vec[i16]
L0:
    r0 = VecI16Api.alloc(0, 0)
    return r0
def create_u8():
    r0 :: vec[u8]
L0:
    r0 = VecU8Api.alloc(0, 0)
    return r0
def create_bool():
    r0 :: vec[bool]
L0:
    r0 = VecBoolApi.alloc(0, 0)
    return r0

[case testVecMiscCreateFromList]
from librt.vecs import vec

from mypy_extensions import i64, i32

def create_i32() -> vec[i32]:
    return vec[i32]([1, -5])
[out]
def create_i32():
    r0 :: vec[i32]
    r1, r2, r3 :: ptr
L0:
    r0 = VecI32Api.alloc(2, 2)
    r1 = r0.items
    set_mem r1, 1 :: i32*
    r2 = r1 + 4
    set_mem r2, -5 :: i32*
    r3 = r2 + 4
    keep_alive r0
    return r0

[case testVecMiscLen_64bit]
from librt.vecs import vec

from mypy_extensions import i64, i32

def len_i32(v: vec[i32]) -> i64:
    return len(v)
[out]
def len_i32(v):
    v :: vec[i32]
    r0 :: native_int
L0:
    r0 = v.len
    return r0

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

from mypy_extensions import i32

def append_float(v: vec[float]) -> vec[float]:
    return append(v, 1.5)

def append_i32(v: vec[i32]) -> vec[i32]:
    return append(v, 123)
[out]
def append_float(v):
    v, r0 :: vec[float]
L0:
    r0 = VecFloatApi.append(v, 1.5)
    return r0
def append_i32(v):
    v, r0 :: vec[i32]
L0:
    r0 = VecI32Api.append(v, 123)
    return r0

[case testVecMiscGetItem_64bit]
from librt.vecs import vec

from mypy_extensions import i64

def get_item_bool(v: vec[bool], i: i64) -> bool:
    return v[i]
[out]
def get_item_bool(v, i):
    v :: vec[bool]
    i :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: bool
L0:
    r0 = v.len
    r1 = i < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = i + 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 = i
L5:
    r6 = v.items
    r7 = r5 * 1
    r8 = r6 + r7
    r9 = load_mem r8 :: builtins.bool*
    keep_alive v
    return r9

[case testVecMiscPop]
from librt.vecs import vec, pop

from mypy_extensions import i64

def pop_float(v: vec[float], i: i64) -> float:
    v, x = pop(v)
    return x
[out]
def pop_float(v, i):
    v :: vec[float]
    i :: i64
    r0 :: tuple[vec[float], float]
    r1 :: vec[float]
    r2 :: float
    r3 :: vec[float]
    r4, x :: float
L0:
    r0 = VecFloatApi.pop(v, -1)
    r1 = borrow r0[0]
    r2 = borrow r0[1]
    keep_alive steal r0
    r3 = unborrow r1
    v = r3
    r4 = unborrow r2
    x = r4
    return x

[case testVecMiscRemove]
from librt.vecs import vec, remove

def remove_float(v: vec[float]) -> vec[float]:
    return remove(v, 1.5)
[out]
def remove_float(v):
    v, r0 :: vec[float]
L0:
    r0 = VecFloatApi.remove(v, 1.5)
    return r0

[case testVecMiscSlice]
from librt.vecs import vec, remove

from mypy_extensions import i64

def remove_float(v: vec[float], x: i64, y: i64) -> vec[float]:
    return v[x:y]
[out]
def remove_float(v, x, y):
    v :: vec[float]
    x, y :: i64
    r0 :: vec[float]
L0:
    r0 = VecFloatApi.slice(v, x, y)
    return r0

[case testVecMiscForLoop]
from librt.vecs import vec, remove

from mypy_extensions import i64, i16

def for_bool(v: vec[i16]) -> i16:
    s: i16 = 0
    for x in v:
        s += x
    return s
[out]
def for_bool(v):
    v :: vec[i16]
    s :: i16
    r0, r1 :: native_int
    r2 :: bit
    r3 :: ptr
    r4 :: native_int
    r5 :: ptr
    r6, x, r7 :: i16
    r8 :: native_int
L0:
    s = 0
    r0 = 0
L1:
    r1 = v.len
    r2 = r0 < r1 :: signed
    if r2 goto L2 else goto L4 :: bool
L2:
    r3 = v.items
    r4 = r0 * 2
    r5 = r3 + r4
    r6 = load_mem r5 :: i16*
    x = r6
    keep_alive v
    r7 = s + x
    s = r7
L3:
    r8 = r0 + 1
    r0 = r8
    goto L1
L4:
    return s

[case testVecMiscNestedGetItem_64bit]
from librt.vecs import vec

from mypy_extensions import i64, i32

def get_item_nested(v: vec[vec[i32]], i: i64) -> vec[i32]:
    return v[i]
[out]
def get_item_nested(v, i):
    v :: vec[vec[i32]]
    i :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: ptr
    r7 :: i64
    r8 :: ptr
    r9 :: vec[i32]
L0:
    r0 = v.len
    r1 = i < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = i + 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 = i
L5:
    r6 = v.items
    r7 = r5 * 16
    r8 = r6 + r7
    r9 = load_mem r8 :: vec[i32]*
    keep_alive v
    return r9

[case testVecMiscNestedPop_64bit]
from librt.vecs import vec, pop

from mypy_extensions import i64, i32

def get_item_nested(v: vec[vec[i32]], i: i64) -> vec[i32]:
    v, x = pop(v, i)
    return x
[out]
def get_item_nested(v, i):
    v :: vec[vec[i32]]
    i :: i64
    r0 :: tuple[vec[vec[i32]], VecNestedBufItem{len:native_int, items:ptr}]
    r1, r2 :: vec[vec[i32]]
    r3, r4 :: VecNestedBufItem{len:native_int, items:ptr}
    r5 :: native_int
    r6 :: ptr
    r7, r8 :: vec[i32]
    r9 :: tuple[vec[vec[i32]], vec[i32]]
    r10 :: vec[vec[i32]]
    r11 :: vec[i32]
    r12 :: vec[vec[i32]]
    r13, x :: vec[i32]
L0:
    r0 = VecNestedApi.pop(v, i)
    r1 = borrow r0[0]
    r2 = unborrow r1
    r3 = borrow r0[1]
    r4 = unborrow r3
    r5 = r4.len
    r6 = r4.items
    r7 = set_element undef vec[i32], len, r5
    r8 = set_element r7, items, r6
    r9 = (r2, r8)
    keep_alive steal r0
    r10 = borrow r9[0]
    r11 = borrow r9[1]
    keep_alive steal r9
    r12 = unborrow r10
    v = r12
    r13 = unborrow r11
    x = r13
    return x

[case testVecU8ToBytes]
from librt.vecs import vec
from mypy_extensions import u8

def to_bytes(v: vec[u8]) -> bytes:
    return bytes(v)
[out]
def to_bytes(v):
    v :: vec[u8]
    r0 :: bytes
L0:
    r0 = CPyVecU8_ToBytes(v)
    return r0