1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
"""Check unpacking non-sequences in assignments. """
# pylint: disable=too-few-public-methods, invalid-name, attribute-defined-outside-init, unused-variable, no-absolute-import
# pylint: disable=using-constant-test, no-init
from os import rename as nonseq_func
from six import with_metaclass
from functional.unpacking import nonseq
__revision__ = 0
# Working
class Seq(object):
""" sequence """
def __init__(self):
self.items = range(2)
def __getitem__(self, item):
return self.items[item]
def __len__(self):
return len(self.items)
class Iter(object):
""" Iterator """
def __iter__(self):
for number in range(2):
yield number
def good_unpacking():
""" returns should be unpackable """
if True:
return [1, 2]
else:
return (3, 4)
def good_unpacking2():
""" returns should be unpackable """
return good_unpacking()
class MetaIter(type):
"metaclass that makes classes that use it iterables"
def __iter__(cls):
return iter((1, 2))
class IterClass(with_metaclass(MetaIter)):
"class that is iterable (and unpackable)"
class AbstrClass(object):
"abstract class"
pair = None
def setup_pair(self):
"abstract method"
raise NotImplementedError
def __init__(self):
"error should not be emitted because setup_pair is abstract"
self.setup_pair()
x, y = self.pair
a, b = [1, 2]
a, b = (1, 2)
a, b = set([1, 2])
a, b = {1: 2, 2: 3}
a, b = "xy"
a, b = Seq()
a, b = Iter()
a, b = (number for number in range(2))
a, b = good_unpacking()
a, b = good_unpacking2()
a, b = IterClass
# Not working
class NonSeq(object):
""" does nothing """
a, b = NonSeq() # [unpacking-non-sequence]
a, b = ValueError # [unpacking-non-sequence]
a, b = None # [unpacking-non-sequence]
a, b = 1 # [unpacking-non-sequence]
a, b = nonseq # [unpacking-non-sequence]
a, b = nonseq() # [unpacking-non-sequence]
a, b = nonseq_func # [unpacking-non-sequence]
class ClassUnpacking(object):
""" Check unpacking as instance attributes. """
def test(self):
""" test unpacking in instance attributes. """
self.a, self.b = 1, 2
self.a, self.b = {1: 2, 2: 3}
self.a, self.b = "xy"
self.a, c = "xy"
c, self.a = good_unpacking()
self.a, self.b = Iter()
self.a, self.b = NonSeq() # [unpacking-non-sequence]
self.a, self.b = ValueError # [unpacking-non-sequence]
self.a, c = nonseq_func # [unpacking-non-sequence]
class TestBase(object):
'base class with `test` method implementation'
@staticmethod
def test(data):
'default implementation'
return data
class Test(TestBase):
'child class that overrides `test` method'
def __init__(self):
# no error should be emitted here as `test` is overriden in this class
(self.aaa, self.bbb, self.ccc) = self.test(None)
@staticmethod
def test(data):
'overridden implementation'
return (1, 2, 3)
|
