mypyc/test-data/alwaysdefined.test

-- 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: []