Path 1: 3898 calls (0.42)

→ node AssignName (3898)

6 run 37 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 2: 1743 calls (0.19)

→ node AssignName (1743)

8 run 35 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 3: 778 calls (0.08)

→ node AssignName (778)

15 run 28 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 4: 558 calls (0.06)

→ node AssignName (558)

14 run 29 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 5: 548 calls (0.06)

→ node AssignName (548)

7 run 36 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 6: 422 calls (0.05)

→ node AssignName (422)

11 run 32 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 7: 319 calls (0.03)

→ node AssignName (319)

4 run 39 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 8: 217 calls (0.02)

→ node AssignName (217)

8 run 35 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 9: 204 calls (0.02)

→ node AssignName (204)

6 run 37 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 10: 109 calls (0.01)

→ node AssignName (109)

9 run 34 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 11: 92 calls (0.01)

→ node AssignName (92)

12 run 31 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 12: 85 calls (0.01)

→ node AssignName (85)

12 run 31 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 13: 59 calls (0.01)

→ node AssignName (59)

15 run 28 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 14: 46 calls (0.01)

→ node AssignName (46)

18 run 25 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 15: 38 calls (0.0)

→ node AssignName (38)

7 run 36 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 16: 22 calls (0.0)

→ node AssignName (22)

14 run 29 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 17: 12 calls (0.0)

→ node AssignName (12)

17 run 26 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 18: 10 calls (0.0)

→ node AssignName (10)

14 run 29 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 19: 4 calls (0.0)

→ node AssignName (4)

14 run 29 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 20: 4 calls (0.0)

→ node AssignName (4)

9 run 34 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 21: 4 calls (0.0)

→ node AssignName (4)

12 run 31 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 22: 2 calls (0.0)

→ node AssignName (2)

9 run 34 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 23: 2 calls (0.0)

→ node AssignName (2)

16 run 27 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)
            

Path 24: 1 calls (0.0)

→ node AssignName (1)

7 run 36 not run

1@utils.only_required_for_messages(
2        "disallowed-name",
3        "invalid-name",
4        "typevar-name-incorrect-variance",
5        "typevar-double-variance",
6        "typevar-name-mismatch",
7    )
8    def visit_assignname(self, node: nodes.AssignName) -> None:
9        """Check module level assigned names."""
10        frame = node.frame(future=True)
11        assign_type = node.assign_type()
12
13        # Check names defined in comprehensions
14        if isinstance(assign_type, nodes.Comprehension):
15            self._check_name("inlinevar", node.name, node)
16
17        # Check names defined in module scope
18        elif isinstance(frame, nodes.Module):
19            # Check names defined in Assign nodes
20            if isinstance(assign_type, nodes.Assign):
21                inferred_assign_type = utils.safe_infer(assign_type.value)
22
23                # Check TypeVar's assigned alone or in tuple assignment
24                if isinstance(node.parent, nodes.Assign) and self._assigns_typevar(
25                    assign_type.value
26                ):
27                    self._check_name("typevar", assign_type.targets[0].name, node)
28                elif (
29                    isinstance(node.parent, nodes.Tuple)
30                    and isinstance(assign_type.value, nodes.Tuple)
31                    # protect against unbalanced tuple unpacking
32                    and node.parent.elts.index(node) < len(assign_type.value.elts)
33                    and self._assigns_typevar(
34                        assign_type.value.elts[node.parent.elts.index(node)]
35                    )
36                ):
37                    self._check_name(
38                        "typevar",
39                        assign_type.targets[0].elts[node.parent.elts.index(node)].name,
40                        node,
41                    )
42
43                # Check classes (TypeVar's are classes so they need to be excluded first)
44                elif isinstance(inferred_assign_type, nodes.ClassDef):
45                    self._check_name("class", node.name, node)
46
47                # Don't emit if the name redefines an import in an ImportError except handler.
48                elif not _redefines_import(node) and isinstance(
49                    inferred_assign_type, nodes.Const
50                ):
51                    self._check_name("const", node.name, node)
52                else:
53                    self._check_name(
54                        "variable", node.name, node, disallowed_check_only=True
55                    )
56
57            # Check names defined in AnnAssign nodes
58            elif isinstance(
59                assign_type, nodes.AnnAssign
60            ) and utils.is_assign_name_annotated_with(node, "Final"):
61                self._check_name("const", node.name, node)
62
63        # Check names defined in function scopes
64        elif isinstance(frame, nodes.FunctionDef):
65            # global introduced variable aren't in the function locals
66            if node.name in frame and node.name not in frame.argnames():
67                if not _redefines_import(node):
68                    self._check_name("variable", node.name, node)
69
70        # Check names defined in class scopes
71        elif isinstance(frame, nodes.ClassDef):
72            if not list(frame.local_attr_ancestors(node.name)):
73                for ancestor in frame.ancestors():
74                    if utils.is_enum(ancestor) or utils.is_assign_name_annotated_with(
75                        node, "Final"
76                    ):
77                        self._check_name("class_const", node.name, node)
78                        break
79                else:
80                    self._check_name("class_attribute", node.name, node)