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