jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-traits.test

@@ -1,411 +0,0 @@
-[case testTraitBasic1]
-from mypy_extensions import trait
-
-class A:
-    line: int
-    def foo(self) -> None:
-        print("foo")
-
-@trait
-class T:
-    def bar(self) -> None:
-        print("bar")
-    def baz(self) -> object:
-        return None
-
-class C(A, T):
-    def baz(self) -> int:
-        return 10
-
-def use_t(t: T) -> object:
-    t.bar()
-    return t.baz()
-
-def use_c(c: C) -> int:
-    use_t(c)
-    c.foo()
-    c.bar()
-    return c.baz()
-
-use_t(C())
-
-# This trait is dead code but there's no reason it shouldn't compile
-@trait
-class ChildlessTrait:
-    def __init__(self) -> None:
-        pass
-
-[file driver.py]
-from native import A, T, C, use_c, use_t
-c = C()
-c.foo()
-c.bar()
-assert c.baz() == 10
-assert use_c(c) == 10
-assert use_t(c) == 10
-[out]
-bar
-foo
-bar
-bar
-foo
-bar
-bar
-
-[case testTraitBasic2]
-from mypy_extensions import trait
-
-class A:
-    line: int
-    def foo(self) -> None:
-        print("foo")
-
-@trait
-class T:
-    def bar(self) -> None:
-        print("bar", self.baz())
-    def baz(self) -> int:
-        return -1
-
-@trait
-class T2:
-    line: int
-    def baz(self) -> int:
-        return -2
-
-class C(A, T):
-    def __init__(self) -> None:
-        self.line = 1337
-        self.x = 12
-    def baz(self) -> int:
-        return self.x
-
-class D(C, T2):
-    def __init__(self) -> None:
-        self.line = 1337
-        self.x = 13
-
-@trait
-class T3:
-    def baz(self) -> int:
-        return -2
-
-class E(T3):
-    def __init__(self) -> None:
-        pass
-
-
-def use_t(t: T) -> None:
-    t.bar()
-def use_t2(t: T2) -> int:
-    t.line = t.line
-    return t.line
-
-def use_c(c: C) -> int:
-    use_t(c)
-    c.foo()
-    c.bar()
-    return c.line
-
-def use_d(d: D) -> int:
-    return d.baz()
-
-[file driver.py]
-from native import A, T, C, D, use_c, use_t, use_d, use_t2
-c = C()
-d = D()
-c.foo()
-c.bar()
-print("baz", c.baz())
-print("baz", d.baz())
-use_c(c)
-use_t(c)
-use_c(d)
-use_t(d)
-assert use_d(d) == 13
-print(d.line)
-assert d.line == 1337
-assert use_t2(d) == 1337
-[out]
-foo
-bar 12
-baz 12
-baz 13
-bar 12
-foo
-bar 12
-bar 12
-bar 13
-foo
-bar 13
-bar 13
-1337
-
-[case testTrait3]
-from mypy_extensions import trait
-from typing import Generic, TypeVar
-
-@trait
-class T1: pass
-@trait
-class T2: pass
-
-T = TypeVar('T')
-
-class C(Generic[T], T1, T2):
-    pass
-
-@trait
-class S1(Generic[T]):
-    def foo(self) -> None: pass
-    def bar(self, x: T) -> T: raise Exception
-
-@trait
-class S2(S1[T]):
-    def bar(self, x: T) -> T: return x
-
-@trait
-class S3(S2[T]):
-    def bar(self, x: T) -> T: return x
-
-class D(S3[bool]):
-    def bar(self, x: bool) -> bool: return x
-
-
-[file driver.py]
-import native
-
-[case testTrait4]
-from mypy_extensions import trait
-from typing import Generic, TypeVar
-
-T = TypeVar('T')
-
-
-@trait
-class S1(Generic[T]):
-    def bar(self) -> T: raise Exception
-
-class S2(S1[bool]):
-    def bar(self) -> bool: return False
-
-class D(S2):
-    pass
-
-def lol(x: S1) -> None:
-    x.bar()
-
-[file driver.py]
-import native
-native.lol(native.D())
-
-[case testTraitOrdering]
-import other_b
-# Regression test for a bug where inheriting from a class that
-# inherited from a trait that got processed later on the command line
-# filed to compile.
-[file other_b.py]
-from other_c import Plugin
-
-class Whatever(Plugin):
-    pass
-
-[file other_c.py]
-from mypy_extensions import trait
-
-@trait
-class Base:
-    x = None  # type: int
-
-class Plugin(Base):
-    def __init__(self) -> None:
-        self.x = 10
-
-[file driver.py]
-from native import *
-
-[case testDiamond]
-from mypy_extensions import trait
-
-@trait
-class Base:
-    def get_value(self) -> str:
-        return "Base"
-
-@trait
-class Trait(Base):
-    def get_value(self) -> str:
-        return "Trait"
-
-class Message(Base):
-    def show_message(self) -> None:
-        print("I am a " + self.get_value())
-
-class DerivedMessage(Message, Trait):
-    pass
-
-[file driver.py]
-from native import *
-a = Message()
-a.show_message()
-b = DerivedMessage()
-b.show_message()
-
-[out]
-I am a Base
-I am a Trait
-
-[case testTraitAttrsSubTrait]
-from mypy_extensions import trait
-
-class A:
-    a: int
-
-@trait
-class T1:
-    x: int
-
-@trait
-class T2(T1):
-    y: int
-
-class C(A, T2):
-    c: int
-
-def f(t1: T1, t2: T2) -> None:
-    t1.x, t2.x = t2.x, t1.x
-
-def g(t1: T1, t2: T2) -> None:
-    t2.y = t1.x
-
-def get_x(c: C) -> int:
-    return c.x
-
-def get_y(c: C) -> int:
-    return c.y
-
-[file driver.py]
-from native import C, f, g, get_x, get_y
-
-c1 = C()
-c2 = C()
-
-c1.x = 1
-c1.y = 0
-c2.x = 2
-c2.y = 0
-
-f(c1, c2)
-assert c1.x == 2
-assert c2.x == 1
-assert get_x(c1) == 2
-assert get_x(c2) == 1
-
-assert get_y(c2) == 0
-g(c1, c2)
-assert get_y(c2) == 2
-[out]
-
-[case testTraitAttrsTriangle]
-from mypy_extensions import trait
-
-class A:
-    a: int
-
-@trait
-class T(A):
-    x: int
-    def meth(self) -> int:
-        return self.a
-
-class B(A):
-    b: int
-
-class C(B, T):
-    pass
-
-def take_t(t: T) -> int:
-    return t.x + t.meth()
-
-def take_c(c: C) -> int:
-    return c.x + c.meth()
-
-[file driver.py]
-from native import C, take_t, take_c
-
-c = C()
-c.a = 1
-c.x = 10
-
-assert take_t(c) == take_c(c) == 11
-[out]
-
-[case testTraitAttrsTree]
-from mypy_extensions import trait
-
-class A:
-    a: int
-
-@trait
-class T1:
-    x: int
-
-class B(A, T1):
-    b: int
-
-@trait
-class T2:
-    x: int
-
-class C(B, T2):
-    pass
-
-def f(t1: T1, t2: T2) -> None:
-    t1.x, t2.x = t2.x, t1.x
-
-def g(c1: C, c2: C) -> None:
-    c1.x, c2.x = c2.x, c1.x
-
-[file driver.py]
-from native import C, f, g
-
-c1 = C()
-c2 = C()
-
-c1.x = 1
-c2.x = 2
-
-f(c1, c2)
-assert c1.x == 2
-assert c2.x == 1
-
-g(c1, c2)
-assert c1.x == 1
-assert c2.x == 2
-[out]
-
-[case testTraitErrorMessages]
-from mypy_extensions import trait
-
-@trait
-class Trait:
-    pass
-
-def create() -> Trait:
-    return Trait()
-
-[file driver.py]
-from native import Trait, create
-from testutil import assertRaises
-
-with assertRaises(TypeError, "traits may not be directly created"):
-    Trait()
-
-with assertRaises(TypeError, "traits may not be directly created"):
-    create()
-
-class Sub(Trait):
-    pass
-
-with assertRaises(TypeError, "interpreted classes cannot inherit from compiled traits"):
-    Sub()

jaclang/vendor/mypyc/test-data/run-tuples.test

@@ -1,258 +0,0 @@
-# Test cases for tuples (compile and run)
-
-[case testTuple]
-from typing import List, Optional, Tuple
-from typing import Tuple
-def f(x: Tuple[int, int]) -> Tuple[int,int]:
-    return x
-
-def lurr(x: List[Optional[Tuple[int, str]]]) -> object:
-    return x[0]
-
-def asdf(x: Tuple[int, str]) -> None:
-    pass
-[file driver.py]
-from testutil import assertRaises
-from native import f, lurr, asdf
-
-assert f((1,2)) == (1, 2)
-assert lurr([(1, '2')]) == (1, '2')
-
-with assertRaises(TypeError):
-    print(lurr([(1, 2)]))
-
-with assertRaises(TypeError):
-    asdf((1, 2))
-
-[case testTupleGet]
-from typing import Tuple
-def f(x: Tuple[Tuple[int, bool], int]) -> int:
-    return x[0][0]
-[file driver.py]
-from native import f
-print(f(((1,True),2)))
-big_number = pow(2, 80)
-print(f(((big_number,True),2)))
-[out]
-1
-1208925819614629174706176
-
-[case testSequenceTupleArg]
-from typing import Tuple
-def f(x: Tuple[int, ...]) -> int:
-    return x[1]
-[file driver.py]
-from native import f
-print(f((1,2,3,4)))
-[out]
-2
-
-[case testTupleAttr]
-from typing import Tuple
-class C:
-    b: Tuple[Tuple[Tuple[int, int], int], int, str, object]
-    c: Tuple[()]
-def f() -> None:
-    c = C()
-    c.b = (((1, 2), 2), 1, 'hi', 'hi2')
-    print(c.b)
-
-def g() -> None:
-    try:
-        h()
-    except Exception:
-        print('caught the exception')
-
-def h() -> Tuple[Tuple[Tuple[int, int], int], int, str, object]:
-    raise Exception('Intentional exception')
-[file driver.py]
-from native import f, g, C
-f()
-g()
-assert not hasattr(C(), 'c')
-[out]
-(((1, 2), 2), 1, 'hi', 'hi2')
-caught the exception
-
-[case testNamedTupleAttributeRun]
-from typing import NamedTuple
-
-NT = NamedTuple('NT', [('x', int), ('y', int)])
-
-def f(nt: NT) -> int:
-    if nt.x > nt.y:
-        return nt.x
-    return nt.y
-
-nt = NT(1, 2)
-[file driver.py]
-from native import NT, nt, f
-
-assert f(nt) == 2
-assert f(NT(3, 2)) == 3
-
-class Sub(NT):
-    pass
-assert f(Sub(3, 2)) == 3
-
--- Ref: https://github.com/mypyc/mypyc/issues/924
-[case testNamedTupleClassSyntax]
-from typing import Dict, List, NamedTuple, Optional, Tuple, Union
-from typing_extensions import final
-
-class FuncIR: pass
-
-StealsDescription = Union[bool, List[bool]]
-
-class Record(NamedTuple):
-    st_mtime: float
-    st_size: int
-    is_borrowed: bool
-    hash: str
-    python_path: Tuple[str, ...]
-    type: 'ClassIR'
-    method: FuncIR
-    shadow_method: Optional[FuncIR]
-    classes: Dict[str, 'ClassIR']
-    steals: StealsDescription
-    ordering: Optional[List[int]]
-    extra_int_constants: List[Tuple[int]]
-
-# Make sure mypyc loads the annotation string for this forward reference.
-# Ref: https://github.com/mypyc/mypyc/issues/938
-class ClassIR: pass
-
-# Ref: https://github.com/mypyc/mypyc/issues/927
-@final
-class Inextensible(NamedTuple):
-    x: int
-
-[file driver.py]
-from typing import ForwardRef, Optional
-from native import ClassIR, FuncIR, Record
-
-assert Record.__annotations__ == {
-    'st_mtime': float,
-    'st_size': int,
-    'is_borrowed': bool,
-    'hash': str,
-    'python_path': tuple,
-    'type': ForwardRef('ClassIR'),
-    'method': FuncIR,
-    'shadow_method': type,
-    'classes': dict,
-    'steals': type,
-    'ordering': type,
-    'extra_int_constants': list,
-}, Record.__annotations__
-
-[case testTupleOps]
-from typing import Tuple, List, Any, Optional
-from typing_extensions import Final
-
-def f() -> Tuple[()]:
-    return ()
-
-def test_empty_tuple() -> None:
-    assert f() == ()
-
-def f2() -> Any:
-    return ()
-
-def test_empty_tuple_with_any_type():
-    assert f2() == ()
-
-def f3() -> int:
-    x = (False, 1)
-    return x[1]
-
-def test_new_tuple() -> None:
-    assert f3() == 1
-
-def f4(y: int) -> int:
-    x = (False, y)
-    return x[1]
-
-def test_new_tuple_boxed_int() -> None:
-    big_number = 1208925819614629174706176
-    assert f4(big_number) == big_number
-
-def f5(x: List[int]) -> int:
-    return tuple(x)[1]
-
-def test_sequence_tuple() -> None:
-    assert f5([1,2,3,4]) == 2
-
-def f6(x: List[int]) -> int:
-    return len(tuple(x))
-
-def test_sequence_tuple_len() -> None:
-    assert f6([1,2,3,4]) == 4
-
-def f7(x: List[Tuple[int, int]]) -> int:
-    a, b = x[0]
-    return a + b
-
-def test_unbox_tuple() -> None:
-    assert f7([(5, 6)]) == 11
-
-# Test that order is irrelevant to unions. Really I only care that this builds.
-
-class A:
-    pass
-
-def lol() -> A:
-    return A()
-
-def foo(x: bool, y: bool) -> Tuple[Optional[A], bool]:
-    z = lol()
-
-    return None if y else z, x
-
-def test_slicing() -> None:
-    # Use dummy adds to avoid constant folding
-    zero = int()
-    two = zero + 2
-    s: Tuple[str, ...] = ("f", "o", "o", "b", "a", "r")
-    assert s[two:] == ("o", "b", "a", "r")
-    assert s[:two] == ("f", "o")
-    assert s[two:-two] == ("o", "b")
-    assert s[two:two] == ()
-    assert s[two:two + 1] == ("o",)
-    assert s[-two:] == ("a", "r")
-    assert s[:-two] == ("f", "o", "o", "b")
-    assert s[:] == ("f", "o", "o", "b", "a", "r")
-    assert s[two:333] == ("o", "b", "a", "r")
-    assert s[333:two] == ()
-    assert s[two:-333] == ()
-    assert s[-333:two] == ("f", "o")
-    long_int: int = 1000 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000
-    assert s[1:long_int] == ("o", "o", "b", "a", "r")
-    assert s[long_int:] == ()
-    assert s[-long_int:-1] == ("f", "o", "o", "b", "a")
-
-def f8(val: int) -> bool:
-    return val % 2 == 0
-
-def test_sequence_generator() -> None:
-    source_list = [1, 2, 3]
-    a = tuple(f8(x) for x in source_list)
-    assert a == (False, True, False)
-
-    source_tuple: Tuple[int, ...] = (1, 2, 3)
-    a = tuple(f8(x) for x in source_tuple)
-    assert a == (False, True, False)
-
-    source_fixed_length_tuple = (1, 2, 3, 4)
-    a = tuple(f8(x) for x in source_fixed_length_tuple)
-    assert a == (False, True, False, True)
-
-    source_str = 'abbc'
-    b = tuple('s:' + x for x in source_str)
-    assert b == ('s:a', 's:b', 's:b', 's:c')
-
-TUPLE: Final[Tuple[str, ...]] = ('x', 'y')
-
-def test_final_boxed_tuple() -> None:
-    t = TUPLE
-    assert t == ('x', 'y')