| # Copyright (c) 2007-2013 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr> |
| # Copyright (c) 2010 Daniel Harding <dharding@gmail.com> |
| # Copyright (c) 2014-2016, 2018-2020 Claudiu Popa <pcmanticore@gmail.com> |
| # Copyright (c) 2014 Google, Inc. |
| # Copyright (c) 2015-2016 Ceridwen <ceridwenv@gmail.com> |
| # Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk> |
| # Copyright (c) 2019 Hugo van Kemenade <hugovk@users.noreply.github.com> |
| # Copyright (c) 2020-2021 hippo91 <guillaume.peillex@gmail.com> |
| # Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com> |
| # Copyright (c) 2021 Daniël van Noord <13665637+DanielNoord@users.noreply.github.com> |
| # Copyright (c) 2021 David Liu <david@cs.toronto.edu> |
| # Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com> |
| |
| # Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html |
| # For details: https://github.com/PyCQA/astroid/blob/main/LICENSE |
| |
| """tests for the astroid variable lookup capabilities |
| """ |
| import functools |
| import unittest |
| |
| from astroid import builder, nodes, test_utils |
| from astroid.exceptions import ( |
| AttributeInferenceError, |
| InferenceError, |
| NameInferenceError, |
| ) |
| |
| from . import resources |
| |
| |
| class LookupTest(resources.SysPathSetup, unittest.TestCase): |
| def setUp(self) -> None: |
| super().setUp() |
| self.module = resources.build_file("data/module.py", "data.module") |
| self.module2 = resources.build_file("data/module2.py", "data.module2") |
| self.nonregr = resources.build_file("data/nonregr.py", "data.nonregr") |
| |
| def test_limit(self) -> None: |
| code = """ |
| l = [a |
| for a,b in list] |
| |
| a = 1 |
| b = a |
| a = None |
| |
| def func(): |
| c = 1 |
| """ |
| astroid = builder.parse(code, __name__) |
| # a & b |
| a = next(astroid.nodes_of_class(nodes.Name)) |
| self.assertEqual(a.lineno, 2) |
| self.assertEqual(len(astroid.lookup("b")[1]), 1) |
| self.assertEqual(len(astroid.lookup("a")[1]), 1) |
| b = astroid.locals["b"][0] |
| stmts = a.lookup("a")[1] |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(b.lineno, 6) |
| b_infer = b.infer() |
| b_value = next(b_infer) |
| self.assertEqual(b_value.value, 1) |
| # c |
| self.assertRaises(StopIteration, functools.partial(next, b_infer)) |
| func = astroid.locals["func"][0] |
| self.assertEqual(len(func.lookup("c")[1]), 1) |
| |
| def test_module(self) -> None: |
| astroid = builder.parse("pass", __name__) |
| # built-in objects |
| none = next(astroid.ilookup("None")) |
| self.assertIsNone(none.value) |
| obj = next(astroid.ilookup("object")) |
| self.assertIsInstance(obj, nodes.ClassDef) |
| self.assertEqual(obj.name, "object") |
| self.assertRaises( |
| InferenceError, functools.partial(next, astroid.ilookup("YOAA")) |
| ) |
| |
| # XXX |
| self.assertEqual(len(list(self.nonregr.ilookup("enumerate"))), 2) |
| |
| def test_class_ancestor_name(self) -> None: |
| code = """ |
| class A: |
| pass |
| |
| class A(A): |
| pass |
| """ |
| astroid = builder.parse(code, __name__) |
| cls1 = astroid.locals["A"][0] |
| cls2 = astroid.locals["A"][1] |
| name = next(cls2.nodes_of_class(nodes.Name)) |
| self.assertEqual(next(name.infer()), cls1) |
| |
| ### backport those test to inline code |
| def test_method(self) -> None: |
| method = self.module["YOUPI"]["method"] |
| my_dict = next(method.ilookup("MY_DICT")) |
| self.assertTrue(isinstance(my_dict, nodes.Dict), my_dict) |
| none = next(method.ilookup("None")) |
| self.assertIsNone(none.value) |
| self.assertRaises( |
| InferenceError, functools.partial(next, method.ilookup("YOAA")) |
| ) |
| |
| def test_function_argument_with_default(self) -> None: |
| make_class = self.module2["make_class"] |
| base = next(make_class.ilookup("base")) |
| self.assertTrue(isinstance(base, nodes.ClassDef), base.__class__) |
| self.assertEqual(base.name, "YO") |
| self.assertEqual(base.root().name, "data.module") |
| |
| def test_class(self) -> None: |
| klass = self.module["YOUPI"] |
| my_dict = next(klass.ilookup("MY_DICT")) |
| self.assertIsInstance(my_dict, nodes.Dict) |
| none = next(klass.ilookup("None")) |
| self.assertIsNone(none.value) |
| obj = next(klass.ilookup("object")) |
| self.assertIsInstance(obj, nodes.ClassDef) |
| self.assertEqual(obj.name, "object") |
| self.assertRaises( |
| InferenceError, functools.partial(next, klass.ilookup("YOAA")) |
| ) |
| |
| def test_inner_classes(self) -> None: |
| ddd = list(self.nonregr["Ccc"].ilookup("Ddd")) |
| self.assertEqual(ddd[0].name, "Ddd") |
| |
| def test_loopvar_hiding(self) -> None: |
| astroid = builder.parse( |
| """ |
| x = 10 |
| for x in range(5): |
| print (x) |
| |
| if x > 0: |
| print ('#' * x) |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"] |
| # inside the loop, only one possible assignment |
| self.assertEqual(len(xnames[0].lookup("x")[1]), 1) |
| # outside the loop, two possible assignments |
| self.assertEqual(len(xnames[1].lookup("x")[1]), 2) |
| self.assertEqual(len(xnames[2].lookup("x")[1]), 2) |
| |
| def test_list_comps(self) -> None: |
| astroid = builder.parse( |
| """ |
| print ([ i for i in range(10) ]) |
| print ([ i for i in range(10) ]) |
| print ( list( i for i in range(10) ) ) |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2) |
| self.assertEqual(len(xnames[1].lookup("i")[1]), 1) |
| self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3) |
| self.assertEqual(len(xnames[2].lookup("i")[1]), 1) |
| self.assertEqual(xnames[2].lookup("i")[1][0].lineno, 4) |
| |
| def test_list_comp_target(self) -> None: |
| """test the list comprehension target""" |
| astroid = builder.parse( |
| """ |
| ten = [ var for var in range(10) ] |
| var |
| """ |
| ) |
| var = astroid.body[1].value |
| self.assertRaises(NameInferenceError, var.inferred) |
| |
| def test_dict_comps(self) -> None: |
| astroid = builder.parse( |
| """ |
| print ({ i: j for i in range(10) for j in range(10) }) |
| print ({ i: j for i in range(10) for j in range(10) }) |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2) |
| self.assertEqual(len(xnames[1].lookup("i")[1]), 1) |
| self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3) |
| |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "j"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2) |
| self.assertEqual(len(xnames[1].lookup("i")[1]), 1) |
| self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3) |
| |
| def test_set_comps(self) -> None: |
| astroid = builder.parse( |
| """ |
| print ({ i for i in range(10) }) |
| print ({ i for i in range(10) }) |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2) |
| self.assertEqual(len(xnames[1].lookup("i")[1]), 1) |
| self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3) |
| |
| def test_set_comp_closure(self) -> None: |
| astroid = builder.parse( |
| """ |
| ten = { var for var in range(10) } |
| var |
| """ |
| ) |
| var = astroid.body[1].value |
| self.assertRaises(NameInferenceError, var.inferred) |
| |
| def test_list_comp_nested(self) -> None: |
| astroid = builder.parse( |
| """ |
| x = [[i + j for j in range(20)] |
| for i in range(10)] |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 3) |
| |
| def test_dict_comp_nested(self) -> None: |
| astroid = builder.parse( |
| """ |
| x = {i: {i: j for j in range(20)} |
| for i in range(10)} |
| x3 = [{i + j for j in range(20)} # Can't do nested sets |
| for i in range(10)] |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 3) |
| self.assertEqual(len(xnames[1].lookup("i")[1]), 1) |
| self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3) |
| |
| def test_set_comp_nested(self) -> None: |
| astroid = builder.parse( |
| """ |
| x = [{i + j for j in range(20)} # Can't do nested sets |
| for i in range(10)] |
| """, |
| __name__, |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"] |
| self.assertEqual(len(xnames[0].lookup("i")[1]), 1) |
| self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 3) |
| |
| def test_lambda_nested(self) -> None: |
| astroid = builder.parse( |
| """ |
| f = lambda x: ( |
| lambda y: x + y) |
| """ |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"] |
| self.assertEqual(len(xnames[0].lookup("x")[1]), 1) |
| self.assertEqual(xnames[0].lookup("x")[1][0].lineno, 2) |
| |
| def test_function_nested(self) -> None: |
| astroid = builder.parse( |
| """ |
| def f1(x): |
| def f2(y): |
| return x + y |
| |
| return f2 |
| """ |
| ) |
| xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"] |
| self.assertEqual(len(xnames[0].lookup("x")[1]), 1) |
| self.assertEqual(xnames[0].lookup("x")[1][0].lineno, 2) |
| |
| def test_class_variables(self) -> None: |
| # Class variables are NOT available within nested scopes. |
| astroid = builder.parse( |
| """ |
| class A: |
| a = 10 |
| |
| def f1(self): |
| return a # a is not defined |
| |
| f2 = lambda: a # a is not defined |
| |
| b = [a for _ in range(10)] # a is not defined |
| |
| class _Inner: |
| inner_a = a + 1 |
| """ |
| ) |
| names = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "a"] |
| self.assertEqual(len(names), 4) |
| for name in names: |
| self.assertRaises(NameInferenceError, name.inferred) |
| |
| def test_class_in_function(self) -> None: |
| # Function variables are available within classes, including methods |
| astroid = builder.parse( |
| """ |
| def f(): |
| x = 10 |
| class A: |
| a = x |
| |
| def f1(self): |
| return x |
| |
| f2 = lambda: x |
| |
| b = [x for _ in range(10)] |
| |
| class _Inner: |
| inner_a = x + 1 |
| """ |
| ) |
| names = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"] |
| self.assertEqual(len(names), 5) |
| for name in names: |
| self.assertEqual(len(name.lookup("x")[1]), 1, repr(name)) |
| self.assertEqual(name.lookup("x")[1][0].lineno, 3, repr(name)) |
| |
| def test_generator_attributes(self) -> None: |
| tree = builder.parse( |
| """ |
| def count(): |
| "test" |
| yield 0 |
| |
| iterer = count() |
| num = iterer.next() |
| """ |
| ) |
| next_node = tree.body[2].value.func |
| gener = next_node.expr.inferred()[0] |
| self.assertIsInstance(gener.getattr("__next__")[0], nodes.FunctionDef) |
| self.assertIsInstance(gener.getattr("send")[0], nodes.FunctionDef) |
| self.assertIsInstance(gener.getattr("throw")[0], nodes.FunctionDef) |
| self.assertIsInstance(gener.getattr("close")[0], nodes.FunctionDef) |
| |
| def test_explicit___name__(self) -> None: |
| code = """ |
| class Pouet: |
| __name__ = "pouet" |
| p1 = Pouet() |
| |
| class PouetPouet(Pouet): pass |
| p2 = Pouet() |
| |
| class NoName: pass |
| p3 = NoName() |
| """ |
| astroid = builder.parse(code, __name__) |
| p1 = next(astroid["p1"].infer()) |
| self.assertTrue(p1.getattr("__name__")) |
| p2 = next(astroid["p2"].infer()) |
| self.assertTrue(p2.getattr("__name__")) |
| self.assertTrue(astroid["NoName"].getattr("__name__")) |
| p3 = next(astroid["p3"].infer()) |
| self.assertRaises(AttributeInferenceError, p3.getattr, "__name__") |
| |
| def test_function_module_special(self) -> None: |
| astroid = builder.parse( |
| ''' |
| def initialize(linter): |
| """initialize linter with checkers in this package """ |
| package_load(linter, __path__[0]) |
| ''', |
| "data.__init__", |
| ) |
| path = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "__path__"][ |
| 0 |
| ] |
| self.assertEqual(len(path.lookup("__path__")[1]), 1) |
| |
| def test_builtin_lookup(self) -> None: |
| self.assertEqual(nodes.builtin_lookup("__dict__")[1], ()) |
| intstmts = nodes.builtin_lookup("int")[1] |
| self.assertEqual(len(intstmts), 1) |
| self.assertIsInstance(intstmts[0], nodes.ClassDef) |
| self.assertEqual(intstmts[0].name, "int") |
| self.assertIs(intstmts[0], nodes.const_factory(1)._proxied) |
| |
| def test_decorator_arguments_lookup(self) -> None: |
| code = """ |
| def decorator(value): |
| def wrapper(function): |
| return function |
| return wrapper |
| |
| class foo: |
| member = 10 #@ |
| |
| @decorator(member) #This will cause pylint to complain |
| def test(self): |
| pass |
| """ |
| |
| node = builder.extract_node(code, __name__) |
| assert isinstance(node, nodes.Assign) |
| member = node.targets[0] |
| it = member.infer() |
| obj = next(it) |
| self.assertIsInstance(obj, nodes.Const) |
| self.assertEqual(obj.value, 10) |
| self.assertRaises(StopIteration, functools.partial(next, it)) |
| |
| def test_inner_decorator_member_lookup(self) -> None: |
| code = """ |
| class FileA: |
| def decorator(bla): |
| return bla |
| |
| @__(decorator) |
| def funcA(): |
| return 4 |
| """ |
| decname = builder.extract_node(code, __name__) |
| it = decname.infer() |
| obj = next(it) |
| self.assertIsInstance(obj, nodes.FunctionDef) |
| self.assertRaises(StopIteration, functools.partial(next, it)) |
| |
| def test_static_method_lookup(self) -> None: |
| code = """ |
| class FileA: |
| @staticmethod |
| def funcA(): |
| return 4 |
| |
| |
| class Test: |
| FileA = [1,2,3] |
| |
| def __init__(self): |
| print (FileA.funcA()) |
| """ |
| astroid = builder.parse(code, __name__) |
| it = astroid["Test"]["__init__"].ilookup("FileA") |
| obj = next(it) |
| self.assertIsInstance(obj, nodes.ClassDef) |
| self.assertRaises(StopIteration, functools.partial(next, it)) |
| |
| def test_global_delete(self) -> None: |
| code = """ |
| def run2(): |
| f = Frobble() |
| |
| class Frobble: |
| pass |
| Frobble.mumble = True |
| |
| del Frobble |
| |
| def run1(): |
| f = Frobble() |
| """ |
| astroid = builder.parse(code, __name__) |
| stmts = astroid["run2"].lookup("Frobbel")[1] |
| self.assertEqual(len(stmts), 0) |
| stmts = astroid["run1"].lookup("Frobbel")[1] |
| self.assertEqual(len(stmts), 0) |
| |
| |
| class LookupControlFlowTest(unittest.TestCase): |
| """Tests for lookup capabilities and control flow""" |
| |
| def test_consecutive_assign(self) -> None: |
| """When multiple assignment statements are in the same block, only the last one |
| is returned. |
| """ |
| code = """ |
| x = 10 |
| x = 100 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 3) |
| |
| def test_assign_after_use(self) -> None: |
| """An assignment statement appearing after the variable is not returned.""" |
| code = """ |
| print(x) |
| x = 10 |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 0) |
| |
| def test_del_removes_prior(self) -> None: |
| """Delete statement removes any prior assignments""" |
| code = """ |
| x = 10 |
| del x |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 0) |
| |
| def test_del_no_effect_after(self) -> None: |
| """Delete statement doesn't remove future assignments""" |
| code = """ |
| x = 10 |
| del x |
| x = 100 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 4) |
| |
| def test_if_assign(self) -> None: |
| """Assignment in if statement is added to lookup results, but does not replace |
| prior assignments. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b: |
| x = 100 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 2) |
| self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 5]) |
| |
| def test_if_assigns_same_branch(self) -> None: |
| """When if branch has multiple assignment statements, only the last one |
| is added. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b: |
| x = 100 |
| x = 1000 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 2) |
| self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 6]) |
| |
| def test_if_assigns_different_branch(self) -> None: |
| """When different branches have assignment statements, the last one |
| in each branch is added. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b == 1: |
| x = 100 |
| x = 1000 |
| elif b == 2: |
| x = 3 |
| elif b == 3: |
| x = 4 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 4) |
| self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 6, 8, 10]) |
| |
| def test_assign_exclusive(self) -> None: |
| """When the variable appears inside a branch of an if statement, |
| no assignment statements from other branches are returned. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b == 1: |
| x = 100 |
| x = 1000 |
| elif b == 2: |
| x = 3 |
| elif b == 3: |
| x = 4 |
| else: |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 3) |
| |
| def test_assign_not_exclusive(self) -> None: |
| """When the variable appears inside a branch of an if statement, |
| only the last assignment statement in the same branch is returned. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b == 1: |
| x = 100 |
| x = 1000 |
| elif b == 2: |
| x = 3 |
| elif b == 3: |
| x = 4 |
| print(x) |
| else: |
| x = 5 |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 10) |
| |
| def test_if_else(self) -> None: |
| """When an assignment statement appears in both an if and else branch, both |
| are added. This does NOT replace an assignment statement appearing before the |
| if statement. (See issue #213) |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b: |
| x = 100 |
| else: |
| x = 1000 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 3) |
| self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 5, 7]) |
| |
| def test_if_variable_in_condition_1(self) -> None: |
| """Test lookup works correctly when a variable appears in an if condition.""" |
| code = """ |
| x = 10 |
| if x > 10: |
| print('a') |
| elif x > 0: |
| print('b') |
| """ |
| astroid = builder.parse(code) |
| x_name1, x_name2 = ( |
| n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x" |
| ) |
| |
| _, stmts1 = x_name1.lookup("x") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 2) |
| |
| _, stmts2 = x_name2.lookup("x") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 2) |
| |
| def test_if_variable_in_condition_2(self) -> None: |
| """Test lookup works correctly when a variable appears in an if condition, |
| and the variable is reassigned in each branch. |
| |
| This is based on PyCQA/pylint issue #3711. |
| """ |
| code = """ |
| x = 10 |
| if x > 10: |
| x = 100 |
| elif x > 0: |
| x = 200 |
| elif x > -10: |
| x = 300 |
| else: |
| x = 400 |
| """ |
| astroid = builder.parse(code) |
| x_names = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"] |
| |
| # All lookups should refer only to the initial x = 10. |
| for x_name in x_names: |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 2) |
| |
| def test_del_not_exclusive(self) -> None: |
| """A delete statement in an if statement branch removes all previous |
| assignment statements when the delete statement is not exclusive with |
| the variable (e.g., when the variable is used below the if statement). |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b == 1: |
| x = 100 |
| elif b == 2: |
| del x |
| elif b == 3: |
| x = 4 # Only this assignment statement is returned |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 9) |
| |
| def test_del_exclusive(self) -> None: |
| """A delete statement in an if statement branch that is exclusive with the |
| variable does not remove previous assignment statements. |
| """ |
| code = """ |
| def f(b): |
| x = 10 |
| if b == 1: |
| x = 100 |
| elif b == 2: |
| del x |
| else: |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 3) |
| |
| def test_assign_after_param(self) -> None: |
| """When an assignment statement overwrites a function parameter, only the |
| assignment is returned, even when the variable and assignment do not have |
| the same parent. |
| """ |
| code = """ |
| def f1(x): |
| x = 100 |
| print(x) |
| |
| def f2(x): |
| x = 100 |
| if True: |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name1, x_name2 = ( |
| n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x" |
| ) |
| _, stmts1 = x_name1.lookup("x") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 3) |
| |
| _, stmts2 = x_name2.lookup("x") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 7) |
| |
| def test_assign_after_kwonly_param(self) -> None: |
| """When an assignment statement overwrites a function keyword-only parameter, |
| only the assignment is returned, even when the variable and assignment do |
| not have the same parent. |
| """ |
| code = """ |
| def f1(*, x): |
| x = 100 |
| print(x) |
| |
| def f2(*, x): |
| x = 100 |
| if True: |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name1, x_name2 = ( |
| n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x" |
| ) |
| _, stmts1 = x_name1.lookup("x") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 3) |
| |
| _, stmts2 = x_name2.lookup("x") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 7) |
| |
| @test_utils.require_version(minver="3.8") |
| def test_assign_after_posonly_param(self): |
| """When an assignment statement overwrites a function positional-only parameter, |
| only the assignment is returned, even when the variable and assignment do |
| not have the same parent. |
| """ |
| code = """ |
| def f1(x, /): |
| x = 100 |
| print(x) |
| |
| def f2(x, /): |
| x = 100 |
| if True: |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name1, x_name2 = ( |
| n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x" |
| ) |
| _, stmts1 = x_name1.lookup("x") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 3) |
| |
| _, stmts2 = x_name2.lookup("x") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 7) |
| |
| def test_assign_after_args_param(self) -> None: |
| """When an assignment statement overwrites a function parameter, only the |
| assignment is returned. |
| """ |
| code = """ |
| def f(*args, **kwargs): |
| args = [100] |
| kwargs = {} |
| if True: |
| print(args, kwargs) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "args"][0] |
| _, stmts1 = x_name.lookup("args") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 3) |
| |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "kwargs"][ |
| 0 |
| ] |
| _, stmts2 = x_name.lookup("kwargs") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 4) |
| |
| def test_except_var_in_block(self) -> None: |
| """When the variable bound to an exception in an except clause, it is returned |
| when that variable is used inside the except block. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except ZeroDivisionError as e: |
| print(e) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"][0] |
| _, stmts = x_name.lookup("e") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 4) |
| |
| def test_except_var_in_block_overwrites(self) -> None: |
| """When the variable bound to an exception in an except clause, it is returned |
| when that variable is used inside the except block, and replaces any previous |
| assignments. |
| """ |
| code = """ |
| e = 0 |
| try: |
| 1 / 0 |
| except ZeroDivisionError as e: |
| print(e) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"][0] |
| _, stmts = x_name.lookup("e") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 5) |
| |
| def test_except_var_in_multiple_blocks(self) -> None: |
| """When multiple variables with the same name are bound to an exception |
| in an except clause, and the variable is used inside the except block, |
| only the assignment from the corresponding except clause is returned. |
| """ |
| code = """ |
| e = 0 |
| try: |
| 1 / 0 |
| except ZeroDivisionError as e: |
| print(e) |
| except NameError as e: |
| print(e) |
| """ |
| astroid = builder.parse(code) |
| x_names = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"] |
| |
| _, stmts1 = x_names[0].lookup("e") |
| self.assertEqual(len(stmts1), 1) |
| self.assertEqual(stmts1[0].lineno, 5) |
| |
| _, stmts2 = x_names[1].lookup("e") |
| self.assertEqual(len(stmts2), 1) |
| self.assertEqual(stmts2[0].lineno, 7) |
| |
| def test_except_var_after_block_single(self) -> None: |
| """When the variable bound to an exception in an except clause, it is NOT returned |
| when that variable is used after the except block. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except NameError as e: |
| pass |
| print(e) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"][0] |
| _, stmts = x_name.lookup("e") |
| self.assertEqual(len(stmts), 0) |
| |
| def test_except_var_after_block_multiple(self) -> None: |
| """When the variable bound to an exception in multiple except clauses, it is NOT returned |
| when that variable is used after the except blocks. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except NameError as e: |
| pass |
| except ZeroDivisionError as e: |
| pass |
| print(e) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"][0] |
| _, stmts = x_name.lookup("e") |
| self.assertEqual(len(stmts), 0) |
| |
| def test_except_assign_in_block(self) -> None: |
| """When a variable is assigned in an except block, it is returned |
| when that variable is used in the except block. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except ZeroDivisionError as e: |
| x = 10 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 5) |
| |
| def test_except_assign_in_block_multiple(self) -> None: |
| """When a variable is assigned in multiple except blocks, and the variable is |
| used in one of the blocks, only the assignments in that block are returned. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except ZeroDivisionError: |
| x = 10 |
| except NameError: |
| x = 100 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 7) |
| |
| def test_except_assign_after_block(self) -> None: |
| """When a variable is assigned in an except clause, it is returned |
| when that variable is used after the except block. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except ZeroDivisionError: |
| x = 10 |
| except NameError: |
| x = 100 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 2) |
| self.assertCountEqual([stmt.lineno for stmt in stmts], [5, 7]) |
| |
| def test_except_assign_after_block_overwritten(self) -> None: |
| """When a variable is assigned in an except clause, it is not returned |
| when it is reassigned and used after the except block. |
| """ |
| code = """ |
| try: |
| 1 / 0 |
| except ZeroDivisionError: |
| x = 10 |
| except NameError: |
| x = 100 |
| x = 1000 |
| print(x) |
| """ |
| astroid = builder.parse(code) |
| x_name = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"][0] |
| _, stmts = x_name.lookup("x") |
| self.assertEqual(len(stmts), 1) |
| self.assertEqual(stmts[0].lineno, 8) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
