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

jaclang/vendor/mypyc/test-data/alwaysdefined.test

@@ -1,732 +0,0 @@
--- Test cases for always defined attributes.
---
--- If class C has attributes x and y that are always defined, the output will
--- have a line like this:
---
---   C: [x, y]
-
-[case testAlwaysDefinedSimple]
-class C:
-    def __init__(self, x: int) -> None:
-        self.x = x
-[out]
-C: [x]
-
-[case testAlwaysDefinedFail]
-class MethodCall:
-    def __init__(self, x: int) -> None:
-        self.f()
-        self.x = x
-
-    def f(self) -> None:
-        pass
-
-class FuncCall:
-    def __init__(self, x: int) -> None:
-        f(x)
-        self.x = x
-        f(self)
-        self.y = x
-
-class GetAttr:
-    x: int
-    def __init__(self, x: int) -> None:
-        a = self.x
-        self.x = x
-
-class _Base:
-    def  __init__(self) -> None:
-        f(self)
-
-class CallSuper(_Base):
-    def __init__(self, x: int) -> None:
-        super().__init__()
-        self.x = x
-
-class Lambda:
-    def __init__(self, x: int) -> None:
-        f = lambda x: x + 1
-        self.x = x
-        g = lambda x: self
-        self.y = x
-
-class If:
-    def __init__(self, x: int) -> None:
-        self.a = 1
-        if x:
-            self.x = x
-        else:
-            self.y = 1
-
-class Deletable:
-    __deletable__ = ('x', 'y')
-
-    def __init__(self) -> None:
-        self.x = 0
-        self.y = 1
-        self.z = 2
-
-class PrimitiveWithSelf:
-    def __init__(self, s: str) -> None:
-        self.x = getattr(self, s)
-
-def f(a) -> None: pass
-[out]
-MethodCall: []
-FuncCall: [x]
-GetAttr: []
-CallSuper: []
-Lambda: []
-If: [a]
-Deletable: [z]
-PrimitiveWithSelf: []
-
-[case testAlwaysDefinedConditional]
-class IfAlways:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-            self.y = y
-        elif y:
-            self.x = y
-            self.y = x
-        else:
-            self.x = 0
-            self.y = 0
-        self.z = 0
-
-class IfSometimes1:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-            self.y = y
-        elif y:
-            self.z = y
-            self.y = x
-        else:
-            self.y = 0
-            self.a = 0
-
-class IfSometimes2:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-        self.y = y
-
-class IfStopAnalysis1:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-            f(self)
-        else:
-            self.x = x
-        self.y = y
-
-class IfStopAnalysis2:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-        else:
-            self.x = x
-            f(self)
-        self.y = y
-
-class IfStopAnalysis3:
-    def __init__(self, x: int, y: int) -> None:
-        if x:
-            self.x = x
-        else:
-            f(self)
-            self.x = x
-        self.y = y
-
-class IfConditionalAndNonConditional1:
-    def __init__(self, x: int) -> None:
-        self.x = 0
-        if x:
-            self.x = x
-
-class IfConditionalAndNonConditional2:
-    def __init__(self, x: int) -> None:
-        # x is not considered always defined, since the second assignment may
-        # either initialize or update.
-        if x:
-            self.x = x
-        self.x = 0
-
-def f(a) -> None: pass
-[out]
-IfAlways: [x, y, z]
-IfSometimes1: [y]
-IfSometimes2: [y]
-IfStopAnalysis1: [x]
-IfStopAnalysis2: [x]
-IfStopAnalysis3: []
-IfConditionalAndNonConditional1: [x]
-IfConditionalAndNonConditional2: []
-
-[case testAlwaysDefinedExpressions]
-from typing import Dict, List, Set, Optional, cast
-from typing_extensions import Final
-
-import other
-
-class C: pass
-
-class Collections:
-    def __init__(self, x: int) -> None:
-        self.l = [x]
-        self.d: Dict[str, str] = {}
-        self.s: Set[int] = set()
-        self.d2 = {'x': x}
-        self.s2 = {x}
-        self.l2 = [f(), None] * x
-        self.t = tuple(self.l2)
-
-class Comparisons:
-    def __init__(self, y: int, c: C, s: str, o: Optional[str]) -> None:
-        self.n1 = y < 5
-        self.n2 = y == 5
-        self.c1 = y is c
-        self.c2 = y is not c
-        self.o1 = o is None
-        self.o2 = o is not None
-        self.s = s < 'x'
-
-class BinaryOps:
-    def __init__(self, x: int, s: str) -> None:
-        self.a = x + 2
-        self.b = x & 2
-        self.c = x * 2
-        self.d = -x
-        self.e = 'x' + s
-        self.f = x << x
-
-g = 2
-
-class LocalsAndGlobals:
-    def __init__(self, x: int) -> None:
-        t = x + 1
-        self.a = t - t
-        self.g = g
-
-class Booleans:
-    def __init__(self, x: int, b: bool) -> None:
-        self.a = True
-        self.b = False
-        self.c = not b
-        self.d = b or b
-        self.e = b and b
-
-F: Final = 3
-
-class ModuleFinal:
-    def __init__(self) -> None:
-        self.a = F
-        self.b = other.Y
-
-class ClassFinal:
-    F: Final = 3
-
-    def __init__(self) -> None:
-        self.a = ClassFinal.F
-
-class Literals:
-    def __init__(self) -> None:
-        self.a = 'x'
-        self.b = b'x'
-        self.c = 2.2
-
-class ListComprehension:
-    def __init__(self, x: List[int]) -> None:
-        self.a = [i + 1 for i in x]
-
-class Helper:
-    def __init__(self, arg) -> None:
-        self.x = 0
-
-    def foo(self, arg) -> int:
-        return 1
-
-class AttrAccess:
-    def __init__(self, o: Helper) -> None:
-        self.x = o.x
-        o.x = o.x + 1
-        self.y = o.foo(self.x)
-        o.foo(self)
-        self.z = 1
-
-class Construct:
-    def __init__(self) -> None:
-        self.x = Helper(1)
-        self.y = Helper(self)
-
-class IsInstance:
-    def __init__(self, x: object) -> None:
-        if isinstance(x, str):
-            self.x = 0
-        elif isinstance(x, Helper):
-            self.x = 1
-        elif isinstance(x, (list, tuple)):
-            self.x = 2
-        else:
-            self.x = 3
-
-class Cast:
-    def __init__(self, x: object) -> None:
-        self.x = cast(int, x)
-        self.s = cast(str, x)
-        self.c = cast(Cast, x)
-
-class PropertyAccessGetter:
-    def __init__(self, other: PropertyAccessGetter) -> None:
-        self.x = other.p
-        self.y = 1
-        self.z = self.p
-
-    @property
-    def p(self) -> int:
-        return 0
-
-class PropertyAccessSetter:
-    def __init__(self, other: PropertyAccessSetter) -> None:
-        other.p = 1
-        self.y = 1
-        self.z = self.p
-
-    @property
-    def p(self) -> int:
-        return 0
-
-    @p.setter
-    def p(self, x: int) -> None:
-        pass
-
-def f() -> int:
-    return 0
-
-[file other.py]
-# Not compiled
-from typing_extensions import Final
-
-Y: Final = 3
-
-[out]
-C: []
-Collections: [d, d2, l, l2, s, s2, t]
-Comparisons: [c1, c2, n1, n2, o1, o2, s]
-BinaryOps: [a, b, c, d, e, f]
-LocalsAndGlobals: [a, g]
-Booleans: [a, b, c, d, e]
-ModuleFinal: [a, b]
-ClassFinal: [F, a]
-Literals: [a, b, c]
-ListComprehension: [a]
-Helper: [x]
-AttrAccess: [x, y]
-Construct: [x]
-IsInstance: [x]
-Cast: [c, s, x]
-PropertyAccessGetter: [x, y]
-PropertyAccessSetter: [y]
-
-[case testAlwaysDefinedExpressions2]
-from typing import List, Tuple
-
-class C:
-    def __init__(self) -> None:
-        self.x = 0
-
-class AttributeRef:
-    def __init__(self, c: C) -> None:
-        self.aa = c.x
-        self.bb = self.aa
-        if c is not None:
-            self.z = 0
-        self.cc = 0
-        self.dd = self.z
-
-class ListOps:
-    def __init__(self, x: List[int], n: int) -> None:
-        self.a = len(x)
-        self.b = x[n]
-        self.c = [y + 1 for y in x]
-
-class TupleOps:
-    def __init__(self, t: Tuple[int, str]) -> None:
-        x, y = t
-        self.x = x
-        self.y = t[0]
-        s = x, y
-        self.z = s
-
-class IfExpr:
-    def __init__(self, x: int) -> None:
-        self.a = 1 if x < 5 else 2
-
-class Base:
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-class Derived1(Base):
-    def __init__(self, y: int) -> None:
-        self.aa = y
-        super().__init__(y)
-        self.bb = y
-
-class Derived2(Base):
-    pass
-
-class Conditionals:
-    def __init__(self, b: bool, n: int) -> None:
-        if not (n == 5 or n >= n + 1):
-            self.a = b
-        else:
-            self.a = not b
-        if b:
-            self.b = 2
-        else:
-            self.b = 4
-
-[out]
-C: [x]
-AttributeRef: [aa, bb, cc, dd]
-ListOps: [a, b, c]
-TupleOps: [x, y, z]
-IfExpr: [a]
-Base: [x]
-Derived1: [aa, bb, x]
-Derived2: [x]
-Conditionals: [a, b]
-
-[case testAlwaysDefinedStatements]
-from typing import Any, List, Optional, Iterable
-
-class Return:
-    def __init__(self, x: int) -> None:
-        self.x = x
-        if x > 5:
-            self.y = 1
-            return
-        self.y = 2
-        self.z = x
-
-class While:
-    def __init__(self, x: int) -> None:
-        n = 2
-        while x > 0:
-            n *=2
-            x -= 1
-        self.a = n
-        while x < 5:
-            self.b = 1
-            self.b += 1
-
-class Try:
-    def __init__(self, x: List[int]) -> None:
-        self.a = 0
-        try:
-            self.b = x[0]
-        except:
-            self.c = x
-        self.d = 0
-        try:
-            self.e = x[0]
-        except:
-            self.e = 1
-
-class TryFinally:
-    def __init__(self, x: List[int]) -> None:
-        self.a = 0
-        try:
-            self.b = x[0]
-        finally:
-            self.c = x
-        self.d = 0
-        try:
-            self.e = x[0]
-        finally:
-            self.e = 1
-
-class Assert:
-    def __init__(self, x: Optional[str], y: int) -> None:
-        assert x is not None
-        assert y < 5
-        self.a = x
-
-class For:
-    def __init__(self, it: Iterable[int]) -> None:
-        self.x = 0
-        for x in it:
-            self.x += x
-        for x in it:
-            self.y = x
-
-class Assignment1:
-    def __init__(self, other: Assignment1) -> None:
-        self.x = 0
-        self = other  # Give up after assignment to self
-        self.y = 1
-
-class Assignment2:
-    def __init__(self) -> None:
-        self.x = 0
-        other = self  # Give up after self is aliased
-        self.y = other.x
-
-class With:
-    def __init__(self, x: Any) -> None:
-        self.a = 0
-        with x:
-            self.b = 1
-        self.c = 2
-
-def f() -> None:
-    pass
-
-[out]
-Return: [x, y]
-While: [a]
--- We could infer 'e' as always defined, but this is tricky, since always defined attribute
--- analysis must be performed earlier than exception handling transform. This would be
--- easy to infer *after* exception handling transform.
-Try: [a, d]
--- Again, 'e' could be always defined, but it would be a bit tricky to do it.
-TryFinally: [a, c, d]
-Assert: [a]
-For: [x]
-Assignment1: [x]
-Assignment2: [x]
--- TODO: Why is not 'b' included?
-With: [a, c]
-
-[case testAlwaysDefinedAttributeDefaults]
-class Basic:
-    x = 0
-
-class ClassBodyAndInit:
-    x = 0
-    s = 'x'
-
-    def __init__(self, n: int) -> None:
-        self.n = 0
-
-class AttrWithDefaultAndInit:
-    x = 0
-
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-class Base:
-    x = 0
-    y = 1
-
-class Derived(Base):
-    y = 2
-    z = 3
-[out]
-Basic: [x]
-ClassBodyAndInit: [n, s, x]
-AttrWithDefaultAndInit: [x]
-Base: [x, y]
-Derived: [x, y, z]
-
-[case testAlwaysDefinedWithInheritance]
-class Base:
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-class Deriv1(Base):
-    def __init__(self, x: int, y: str) -> None:
-        super().__init__(x)
-        self.y = y
-
-class Deriv2(Base):
-    def __init__(self, x: int, y: str) -> None:
-        self.y = y
-        super().__init__(x)
-
-class Deriv22(Deriv2):
-    def __init__(self, x: int, y: str, z: bool) -> None:
-        super().__init__(x, y)
-        self.z = False
-
-class Deriv3(Base):
-    def __init__(self) -> None:
-        super().__init__(1)
-
-class Deriv4(Base):
-    def __init__(self) -> None:
-        self.y = 1
-        self.x = 2
-
-def f(a): pass
-
-class BaseUnsafe:
-    def __init__(self, x: int, y: int) -> None:
-        self.x = x
-        f(self)  # Unknown function
-        self.y = y
-
-class DerivUnsafe(BaseUnsafe):
-    def __init__(self, z: int, zz: int) -> None:
-        self.z = z
-        super().__init__(1, 2)  # Calls unknown function
-        self.zz = zz
-
-class BaseWithDefault:
-    x = 1
-
-    def __init__(self) -> None:
-        self.y = 1
-
-class DerivedWithDefault(BaseWithDefault):
-    def __init__(self) -> None:
-        super().__init__()
-        self.z = 1
-
-class AlwaysDefinedInBase:
-    def __init__(self) -> None:
-        self.x = 1
-        self.y = 1
-
-class UndefinedInDerived(AlwaysDefinedInBase):
-    def __init__(self, x: bool) -> None:
-        self.x = 1
-        if x:
-            self.y = 2
-
-class UndefinedInDerived2(UndefinedInDerived):
-    def __init__(self, x: bool):
-        if x:
-            self.y = 2
-[out]
-Base: [x]
-Deriv1: [x, y]
-Deriv2: [x, y]
-Deriv22: [x, y, z]
-Deriv3: [x]
-Deriv4: [x, y]
-BaseUnsafe: [x]
-DerivUnsafe: [x, z]
-BaseWithDefault: [x, y]
-DerivedWithDefault: [x, y, z]
-AlwaysDefinedInBase: []
-UndefinedInDerived: []
-UndefinedInDerived2: []
-
-[case testAlwaysDefinedWithInheritance2]
-from mypy_extensions import trait, mypyc_attr
-
-from interpreted import PythonBase
-
-class BasePartiallyDefined:
-    def __init__(self, x: int) -> None:
-        self.a = 0
-        if x:
-            self.x = x
-
-class Derived1(BasePartiallyDefined):
-    def __init__(self, x: int) -> None:
-        super().__init__(x)
-        self.y = x
-
-class BaseUndefined:
-    x: int
-
-class DerivedAlwaysDefined(BaseUndefined):
-    def __init__(self) -> None:
-        super().__init__()
-        self.z = 0
-        self.x = 2
-
-@trait
-class MyTrait:
-    def f(self) -> None: pass
-
-class SimpleTraitImpl(MyTrait):
-    def __init__(self) -> None:
-        super().__init__()
-        self.x = 0
-
-@trait
-class TraitWithAttr:
-    x: int
-    y: str
-
-class TraitWithAttrImpl(TraitWithAttr):
-    def __init__(self) -> None:
-        self.y = 'x'
-
-@trait
-class TraitWithAttr2:
-    z: int
-
-class TraitWithAttrImpl2(TraitWithAttr, TraitWithAttr2):
-    def __init__(self) -> None:
-        self.y = 'x'
-        self.z = 2
-
-@mypyc_attr(allow_interpreted_subclasses=True)
-class BaseWithGeneralSubclassing:
-    x = 0
-    y: int
-    def __init__(self, s: str) -> None:
-        self.s = s
-
-class Derived2(BaseWithGeneralSubclassing):
-    def __init__(self) -> None:
-        super().__init__('x')
-        self.z = 0
-
-class SubclassPythonclass(PythonBase):
-    def __init__(self) -> None:
-        self.y = 1
-
-class BaseWithSometimesDefined:
-    def __init__(self, b: bool) -> None:
-        if b:
-            self.x = 0
-
-class Derived3(BaseWithSometimesDefined):
-    def __init__(self, b: bool) -> None:
-        super().__init__(b)
-        self.x = 1
-
-[file interpreted.py]
-class PythonBase:
-    def __init__(self) -> None:
-        self.x = 0
-
-[out]
-BasePartiallyDefined: [a]
-Derived1: [a, y]
-BaseUndefined: []
-DerivedAlwaysDefined: [x, z]
-MyTrait: []
-SimpleTraitImpl: [x]
-TraitWithAttr: []
-TraitWithAttrImpl: [y]
-TraitWithAttr2: []
-TraitWithAttrImpl2: [y, z]
-BaseWithGeneralSubclassing: []
--- TODO: 's' could also be always defined
-Derived2: [x, z]
--- Always defined attribute analysis is turned off when inheriting a non-native class.
-SubclassPythonclass: []
-BaseWithSometimesDefined: []
--- TODO: 'x' could also be always defined, but it is a bit tricky to support
-Derived3: []
-
-[case testAlwaysDefinedWithNesting]
-class NestedFunc:
-    def __init__(self) -> None:
-        self.x = 0
-        def f() -> None:
-            self.y = 0
-        f()
-        self.z = 1
-[out]
--- TODO: Support nested functions.
-NestedFunc: []
-f___init___NestedFunc_obj: []