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

-- Test cases for vec[i64]. These also partially cover other unboxed item types,
-- which use a similar runtime representation.

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

def f() -> vec[i64]:
    return vec[i64]()
[out]
def f():
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.alloc(0, 0)
    return r0

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

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

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

def f(v: vec[i64]) -> i64:
    l = len(v)
    return l
[out]
def f(v):
    v :: vec[i64]
    r0 :: native_int
    r1, l :: i64
L0:
    r0 = v.len
    r1 = extend signed r0: native_int to i64
    l = r1
    return l

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

def f(v: vec[i64], i: i64) -> i64:
    return v[i]
[out]
def f(v, i):
    v :: vec[i64]
    i :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5, r6 :: i64
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 = vec_get_item_unsafe[i64] v, r5
    return r6

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

def f(v: vec[i64], i: i64) -> i64:
    return v[i]
[out]
def f(v, i):
    v :: vec[i64]
    i :: i64
    r0 :: native_int
    r1 :: i64
    r2 :: bit
    r3 :: i64
    r4 :: bit
    r5 :: bool
    r6, r7 :: i64
L0:
    r0 = v.len
    r1 = extend signed r0: native_int to i64
    r2 = i < r1 :: unsigned
    if r2 goto L4 else goto L1 :: bool
L1:
    r3 = i + 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 = i
L5:
    r7 = vec_get_item_unsafe[i64] v, r6
    return r7

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

def f(v: vec[i64], i: i64) -> vec[i64]:
    return append(v, i)
[out]
def f(v, i):
    v :: vec[i64]
    i :: i64
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.append(v, i)
    return r0

[case testVecI64Extend]
from librt.vecs import vec, extend
from mypy_extensions import i64
from typing import Iterable

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

[case testVecI64ExtendVec]
from librt.vecs import vec, extend
from mypy_extensions import i64

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

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

def f(v: vec[i64], i: i64, x: i64) -> None:
    v[i] = x
[out]
def f(v, i, x):
    v :: vec[i64]
    i, x :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5 :: i64
    r6 :: ptr
    r7 :: i64
    r8 :: ptr
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 * 8
    r8 = r6 + r7
    set_mem r8, x :: i64*
    keep_alive v
    return 1

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

def f() -> vec[i64]:
    return vec[i64]([1, 5, 14])
[out]
def f():
    r0 :: vec[i64]
    r1, r2, r3, r4 :: ptr
L0:
    r0 = VecI64Api.alloc(3, 3)
    r1 = r0.items
    set_mem r1, 1 :: i64*
    r2 = r1 + 8
    set_mem r2, 5 :: i64*
    r3 = r2 + 8
    set_mem r3, 14 :: i64*
    r4 = r3 + 8
    keep_alive r0
    return r0

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

def f(n: i64) -> vec[i64]:
    return vec[i64]([3] * n)
[out]
def f(n):
    n :: i64
    r0 :: vec[i64]
    r1 :: ptr
    r2 :: i64
    r3, r4 :: ptr
    r5 :: bit
    r6 :: ptr
L0:
    r0 = VecI64Api.alloc(n, n)
    r1 = r0.items
    r2 = n * 8
    r3 = r1 + r2
    r4 = r1
L1:
    r5 = r4 < r3 :: unsigned
    if r5 goto L2 else goto L3 :: bool
L2:
    set_mem r4, 3 :: i64*
    r6 = r4 + 8
    r4 = r6
    goto L1
L3:
    keep_alive r0
    return r0

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

def f(n: i64, x: i64) -> vec[i64]:
    return vec[i64]([x] * 3)
[out]
def f(n, x):
    n, x :: i64
    r0 :: vec[i64]
    r1 :: ptr
    r2 :: native_int
    r3, r4 :: ptr
    r5 :: bit
    r6 :: ptr
L0:
    r0 = VecI64Api.alloc(3, 3)
    r1 = r0.items
    r2 = 3 * 8
    r3 = r1 + r2
    r4 = r1
L1:
    r5 = r4 < r3 :: unsigned
    if r5 goto L2 else goto L3 :: bool
L2:
    set_mem r4, x :: i64*
    r6 = r4 + 8
    r4 = r6
    goto L1
L3:
    keep_alive r0
    return r0

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

def f(n: i64) -> vec[i64]:
    # TODO: Can we pre-allocate a vec with capacity 5?
    return vec[i64]([x + 1 for x in range(i64(5))])
[out]
def f(n):
    n :: i64
    r0, r1 :: vec[i64]
    r2, x :: i64
    r3 :: bit
    r4 :: i64
    r5 :: vec[i64]
    r6 :: i64
L0:
    r0 = VecI64Api.alloc(0, 0)
    r1 = r0
    r2 = 0
    x = r2
L1:
    r3 = r2 < 5 :: signed
    if r3 goto L2 else goto L4 :: bool
L2:
    x = r2
    r4 = x + 1
    r5 = VecI64Api.append(r1, r4)
    r1 = r5
L3:
    r6 = r2 + 1
    r2 = r6
    goto L1
L4:
    return r1

[case testVecI64FastComprehensionFromList_nogil]
from librt.vecs import vec
from mypy_extensions import i64
from typing import List

def f(n: i64, l: List[i64]) -> vec[i64]:
    return vec[i64]([x + 1 for x in l])
[out]
def f(n, l):
    n :: i64
    l :: list
    r0 :: native_int
    r1 :: vec[i64]
    r2, r3 :: native_int
    r4 :: bit
    r5 :: object
    r6, x, r7 :: i64
    r8 :: ptr
    r9 :: native_int
    r10 :: ptr
    r11 :: native_int
L0:
    r0 = var_object_size l
    r1 = VecI64Api.alloc(r0, r0)
    r2 = 0
L1:
    r3 = var_object_size l
    r4 = r2 < r3 :: signed
    if r4 goto L2 else goto L4 :: bool
L2:
    r5 = CPyList_GetItemInt64(l, r2)
    r6 = unbox(i64, r5)
    x = r6
    r7 = x + 1
    r8 = r1.items
    r9 = r2 * 8
    r10 = r8 + r9
    set_mem r10, r7 :: i64*
    keep_alive r1
L3:
    r11 = r2 + 1
    r2 = r11
    goto L1
L4:
    return r1

[case testVecI64FastComprehensionFromVec_64bit]
from librt.vecs import vec
from mypy_extensions import i64
from typing import List

def f(n: i64, v: vec[i64]) -> vec[i64]:
    return vec[i64]([x + 1 for x in v])
[out]
def f(n, v):
    n :: i64
    v :: vec[i64]
    r0 :: native_int
    r1 :: vec[i64]
    r2, r3 :: native_int
    r4 :: bit
    r5, x, r6 :: i64
    r7 :: ptr
    r8 :: native_int
    r9 :: ptr
    r10 :: native_int
L0:
    r0 = v.len
    r1 = VecI64Api.alloc(r0, r0)
    r2 = 0
L1:
    r3 = v.len
    r4 = r2 < r3 :: signed
    if r4 goto L2 else goto L4 :: bool
L2:
    r5 = vec_get_item_unsafe[i64] v, r2
    x = r5
    r6 = x + 1
    r7 = r1.items
    r8 = r2 * 8
    r9 = r7 + r8
    set_mem r9, r6 :: i64*
    keep_alive r1
L3:
    r10 = r2 + 1
    r2 = r10
    goto L1
L4:
    return r1

[case testVecI64ConstructFromRange]
from librt.vecs import vec, pop
from mypy_extensions import i64

def f() -> vec[i64]:
    # TODO: Can we pre-allocate a vec with capacity 7?
    return vec[i64](range(7))
[out]
def f():
    r0, r1 :: vec[i64]
    r2 :: short_int
    r3, ___tmp_6 :: i64
    r4 :: bit
    r5 :: i64
    r6 :: vec[i64]
    r7 :: short_int
L0:
    r0 = VecI64Api.alloc(0, 0)
    r1 = r0
    r2 = 0
    r3 = r2 >> 1
    ___tmp_6 = r3
L1:
    r4 = int_lt r2, 14
    if r4 goto L2 else goto L4 :: bool
L2:
    r5 = r2 >> 1
    ___tmp_6 = r5
    r6 = VecI64Api.append(r1, ___tmp_6)
    r1 = r6
L3:
    r7 = r2 + 2
    r2 = r7
    goto L1
L4:
    return r1

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

def f(v: vec[i64]) -> i64:
    t: i64 = 0
    for x in v:
        t += 1
    return t
[out]
def f(v):
    v :: vec[i64]
    t :: i64
    r0, r1 :: native_int
    r2 :: bit
    r3, x, r4 :: i64
    r5 :: native_int
L0:
    t = 0
    r0 = 0
L1:
    r1 = v.len
    r2 = r0 < r1 :: signed
    if r2 goto L2 else goto L4 :: bool
L2:
    r3 = vec_get_item_unsafe[i64] v, r0
    x = r3
    r4 = t + 1
    t = r4
L3:
    r5 = r0 + 1
    r0 = r5
    goto L1
L4:
    return t

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

def contains(v: vec[i64], n: i64) -> bool:
    return n in v
[out]
def contains(v, n):
    v :: vec[i64]
    n :: i64
    r0 :: native_int
    r1 :: ptr
    r2 :: native_int
    r3, r4 :: ptr
    r5 :: bit
    r6 :: i64
    r7 :: bit
    r8 :: ptr
    r9 :: bool
L0:
    r0 = v.len
    r1 = v.items
    r2 = r0 * 8
    r3 = r1 + r2
    r4 = r1
L1:
    r5 = r4 < r3 :: unsigned
    if r5 goto L2 else goto L4 :: bool
L2:
    r6 = load_mem r4 :: i64*
    r7 = r6 == n
    if r7 goto L5 else goto L3 :: bool
L3:
    r8 = r4 + 8
    r4 = r8
    goto L1
L4:
    keep_alive v
    r9 = 0
    goto L6
L5:
    r9 = 1
L6:
    return r9

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

def f(v: vec[i64]) -> i64:
    return v[0]
[out]
def f(v):
    v :: vec[i64]
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5, r6 :: i64
L0:
    r0 = v.len
    r1 = 0 < r0 :: unsigned
    if r1 goto L4 else goto L1 :: bool
L1:
    r2 = 0 + 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 = 0
L5:
    r6 = vec_get_item_unsafe[i64] v, r5
    return r6

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

def f(v: vec[i64], n: i64, m: i64) -> None:
    a = v[:]
    b = v[n:]
    c = v[n:m]
    d = v[:m]
    e = v[1:-2]
[out]
def f(v, n, m):
    v :: vec[i64]
    n, m :: i64
    r0, a, r1, b, r2, c, r3, d, r4, e :: vec[i64]
L0:
    r0 = VecI64Api.slice(v, 0, 4611686018427387903)
    a = r0
    r1 = VecI64Api.slice(v, n, 4611686018427387903)
    b = r1
    r2 = VecI64Api.slice(v, n, m)
    c = r2
    r3 = VecI64Api.slice(v, 0, m)
    d = r3
    r4 = VecI64Api.slice(v, 1, -2)
    e = r4
    return 1

[case testVecI64Remove]
from librt.vecs import vec, remove
from mypy_extensions import i64

def rem(v: vec[i64], n: i64) -> None:
    v = remove(v, n)
[out]
def rem(v, n):
    v :: vec[i64]
    n :: i64
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.remove(v, n)
    v = r0
    return 1

[case testVecI64PopLast]
from typing import Tuple
from librt.vecs import vec, pop
from mypy_extensions import i64

def pop_last(v: vec[i64]) -> Tuple[vec[i64], i64]:
    return pop(v)
[out]
def pop_last(v):
    v :: vec[i64]
    r0 :: tuple[vec[i64], i64]
L0:
    r0 = VecI64Api.pop(v, -1)
    return r0

[case testVecI64PopNth_64bit]
from typing import Tuple
from librt.vecs import vec, pop
from mypy_extensions import i64

def pop_nth(v: vec[i64], n: i64) -> Tuple[vec[i64], i64]:
    return pop(v, n)
[out]
def pop_nth(v, n):
    v :: vec[i64]
    n :: i64
    r0 :: tuple[vec[i64], i64]
L0:
    r0 = VecI64Api.pop(v, n)
    return r0

[case testVecI64InPlaceOp_64bit]
from librt.vecs import vec, remove
from mypy_extensions import i64

def inplace(v: vec[i64], n: i64, m: i64) -> None:
    v[n] += m
[out]
def inplace(v, n, m):
    v :: vec[i64]
    n, m :: i64
    r0 :: native_int
    r1 :: bit
    r2 :: i64
    r3 :: bit
    r4 :: bool
    r5, r6, r7 :: i64
    r8 :: native_int
    r9 :: bit
    r10 :: i64
    r11 :: bit
    r12 :: bool
    r13 :: i64
    r14 :: ptr
    r15 :: i64
    r16 :: ptr
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[i64] v, r5
    r7 = r6 + m
    r8 = v.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 = v.items
    r15 = r13 * 8
    r16 = r14 + r15
    set_mem r16, r7 :: i64*
    keep_alive v
    return 1

[case testVecI64Narrow]
from librt.vecs import vec
from mypy_extensions import i64
from typing import Optional, Union

def f(x: Optional[vec[i64]]) -> None:
    if x is not None:
        len(x)

def g(x: Union[vec[i64], str]) -> None:
    if isinstance(x, vec):
        len(x)
[out]
def f(x):
    x :: union[vec[i64], None]
    r0 :: object
    r1 :: bit
    r2 :: vec[i64]
    r3 :: native_int
L0:
    r0 = load_address _Py_NoneStruct
    r1 = x != r0
    if r1 goto L1 else goto L2 :: bool
L1:
    r2 = unbox(vec[i64], x)
    r3 = r2.len
L2:
    return 1
def g(x):
    x :: union[vec[i64], str]
    r0 :: bit
    r1 :: vec[i64]
    r2 :: native_int
L0:
    r0 = CPyVec_Check(x)
    if r0 goto L1 else goto L2 :: bool
L1:
    r1 = unbox(vec[i64], x)
    r2 = r1.len
L2:
    return 1

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

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

def cap_variable(n: i64) -> vec[i64]:
    return vec[i64](capacity=n)
[out]
def cap_only():
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.alloc(0, 5)
    return r0
def cap_variable(n):
    n :: i64
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.alloc(0, n)
    return r0

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

def list_with_cap() -> vec[i64]:
    return vec[i64]([1, 2], capacity=5)
[out]
def list_with_cap():
    r0 :: vec[i64]
    r1, r2, r3 :: ptr
L0:
    r0 = VecI64Api.alloc(2, 5)
    r1 = r0.items
    set_mem r1, 1 :: i64*
    r2 = r1 + 8
    set_mem r2, 2 :: i64*
    r3 = r2 + 8
    keep_alive r0
    return r0

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

def repeated_with_cap(n: i64) -> vec[i64]:
    return vec[i64]([3] * n, capacity=10)
[out]
def repeated_with_cap(n):
    n :: i64
    r0 :: vec[i64]
    r1 :: ptr
    r2 :: i64
    r3, r4 :: ptr
    r5 :: bit
    r6 :: ptr
L0:
    r0 = VecI64Api.alloc(n, 10)
    r1 = r0.items
    r2 = n * 8
    r3 = r1 + r2
    r4 = r1
L1:
    r5 = r4 < r3 :: unsigned
    if r5 goto L2 else goto L3 :: bool
L2:
    set_mem r4, 3 :: i64*
    r6 = r4 + 8
    r4 = r6
    goto L1
L3:
    keep_alive r0
    return r0

[case testVecI64ConstructFromIterable]
from typing import Iterable
from librt.vecs import vec
from mypy_extensions import i64

def f(x: Iterable[i64]) -> vec[i64]:
    return vec[i64](x)
[out]
def f(x):
    x :: object
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.from_iterable(x, 0)
    return r0

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

def from_list(a: list[i64]) -> vec[i64]:
    return vec[i64](a)
[out]
def from_list(a):
    a :: list
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.from_iterable(a, 0)
    return r0

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

def from_tuple(a: tuple[i64, ...]) -> vec[i64]:
    return vec[i64](a)
[out]
def from_tuple(a):
    a :: tuple
    r0 :: vec[i64]
L0:
    r0 = VecI64Api.from_iterable(a, 0)
    return r0

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

def to_list(v: vec[i64]) -> list[i64]:
    return list(v)
[out]
def to_list(v):
    v :: vec[i64]
    r0 :: list
L0:
    r0 = VecI64Api.to_list(v)
    return r0

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

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