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
120
121
122
123
124
125
126
127
128
|
"""Test warnings about access to undefined variables."""
# pylint: disable=too-few-public-methods, no-init, no-self-use, old-style-class
DEFINED = 1
if DEFINED != 1:
if DEFINED in (unknown, DEFINED): # [undefined-variable]
DEFINED += 1
def in_method(var):
"""method doc"""
var = nomoreknown # [undefined-variable]
assert var
DEFINED = {DEFINED:__revision__} # [undefined-variable]
# +1:[undefined-variable]
DEFINED[__revision__] = OTHER = 'move this is astroid test'
OTHER += '$'
def bad_default(var, default=unknown2): # [undefined-variable]
"""function with defaut arg's value set to an unexistant name"""
print var, default
print xxxx # [undefined-variable]
augvar += 1 # [undefined-variable,unused-variable]
del vardel # [undefined-variable]
LMBD = lambda x, y=doesnotexist: x+y # [undefined-variable]
LMBD2 = lambda x, y: x+z # [undefined-variable]
try:
POUET # don't catch me
except NameError:
POUET = 'something'
try:
POUETT # don't catch me
except Exception: # pylint:disable = broad-except
POUETT = 'something'
try:
POUETTT # don't catch me
except: # pylint:disable = bare-except
POUETTT = 'something'
print POUET, POUETT, POUETTT
try:
PLOUF # [used-before-assignment]
except ValueError:
PLOUF = 'something'
print PLOUF
def if_branch_test(something):
"""hop"""
if something == 0:
if xxx == 1: # [used-before-assignment]
pass
else:
print xxx
xxx = 3
def decorator(arg):
"""Decorator with one argument."""
return lambda: list(arg)
@decorator(arg=[i * 2 for i in range(15)])
def func1():
"""A function with a decorator that contains a listcomp."""
@decorator(arg=(i * 2 for i in range(15)))
def func2():
"""A function with a decorator that contains a genexpr."""
@decorator(lambda x: x > 0)
def main():
"""A function with a decorator that contains a lambda."""
# Test shared scope.
def test_arguments(arg=TestClass): # [used-before-assignment]
""" TestClass isn't defined yet. """
return arg
class TestClass(Ancestor): # [used-before-assignment]
""" contains another class, which uses an undefined ancestor. """
class MissingAncestor(Ancestor1): # [used-before-assignment]
""" no op """
def test1(self):
""" It should trigger here, because the two classes
have the same scope.
"""
class UsingBeforeDefinition(Empty): # [used-before-assignment]
""" uses Empty before definition """
class Empty(object):
""" no op """
return UsingBeforeDefinition
def test(self):
""" Ancestor isn't defined yet, but we don't care. """
class MissingAncestor1(Ancestor):
""" no op """
return MissingAncestor1
class Self(object):
""" Detect when using the same name inside the class scope. """
obj = Self # [undefined-variable]
class Self1(object):
""" No error should be raised here. """
def test(self):
""" empty """
return Self1
class Ancestor(object):
""" No op """
class Ancestor1(object):
""" No op """
|
