Path 1: 3214 calls (0.87)

→ node Assign (3214)

8 run 21 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 2: 128 calls (0.03)

→ node Assign (128)

12 run 17 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 3: 96 calls (0.03)

→ node Assign (96)

13 run 16 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 4: 90 calls (0.02)

→ node Assign (90)

↩ return None (90)

10 run 19 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 5: 71 calls (0.02)

→ node Assign (71)

11 run 18 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 6: 36 calls (0.01)

→ node Assign (36)

16 run 13 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 7: 24 calls (0.01)

→ node Assign (24)

13 run 16 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 8: 15 calls (0.0)

→ node Assign (15)

↩ return None (15)

11 run 18 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 9: 10 calls (0.0)

→ node Assign (10)

↩ return None (10)

13 run 16 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 10: 4 calls (0.0)

→ node Assign (4)

↩ return None (4)

9 run 20 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 11: 3 calls (0.0)

→ node Assign (3)

18 run 11 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 12: 3 calls (0.0)

→ node Assign (3)

18 run 11 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 13: 1 calls (0.0)

→ node Assign (1)

15 run 14 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 14: 1 calls (0.0)

→ node Assign (1)

21 run 8 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )
            

Path 15: 1 calls (0.0)

→ node Assign (1)

19 run 10 not run

1def _check_self_assigning_variable(self, node: nodes.Assign) -> None:
2        # Detect assigning to the same variable.
3
4        scope = node.scope()
5        scope_locals = scope.locals
6
7        rhs_names = []
8        targets = node.targets
9        if isinstance(targets[0], nodes.Tuple):
10            if len(targets) != 1:
11                # A complex assignment, so bail out early.
12                return
13            targets = targets[0].elts
14            if len(targets) == 1:
15                # Unpacking a variable into the same name.
16                return
17
18        if isinstance(node.value, nodes.Name):
19            if len(targets) != 1:
20                return
21            rhs_names = [node.value]
22        elif isinstance(node.value, nodes.Tuple):
23            rhs_count = len(node.value.elts)
24            if len(targets) != rhs_count or rhs_count == 1:
25                return
26            rhs_names = node.value.elts
27
28        for target, lhs_name in zip(targets, rhs_names):
29            if not isinstance(lhs_name, nodes.Name):
30                continue
31            if not isinstance(target, nodes.AssignName):
32                continue
33            # Check that the scope is different from a class level, which is usually
34            # a pattern to expose module level attributes as class level ones.
35            if isinstance(scope, nodes.ClassDef) and target.name in scope_locals:
36                continue
37            if target.name == lhs_name.name:
38                self.add_message(
39                    "self-assigning-variable", args=(target.name,), node=target
40                )