3.12: add support for type params and type statements (#778)

.github/workflows/test.yml

@@ -33,3 +33,13 @@ jobs:
 
       - name: Tox tests
         run: tox -e py
+  # TODO: after flake8 6.1 include this in the main matrix
+  py312:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.12-dev'
+    - run: pip install --upgrade tox
+    - run: tox -e py312

pyflakes/checker.py

@@ -577,6 +577,10 @@ def unused_annotations(self):
                 yield name, binding
 
 
+class TypeScope(Scope):
+    pass
+
+
 class GeneratorScope(Scope):
     pass
 
@@ -1039,15 +1043,20 @@ def handleNodeLoad(self, node, parent):
         if not name:
             return
 
-        in_generators = None
+        # only the following can access class scoped variables (since classes
+        # aren't really a scope)
+        # - direct accesses (not within a nested scope)
+        # - generators
+        # - type annotations (for generics, etc.)
+        can_access_class_vars = None
         importStarred = None
 
         # try enclosing function scopes and global scope
         for scope in self.scopeStack[-1::-1]:
             if isinstance(scope, ClassScope):
                 if name == '__class__':
                     return
-                elif in_generators is False:
+                elif can_access_class_vars is False:
                     # only generators used in a class scope can access the
                     # names of the class. this is skipped during the first
                     # iteration
@@ -1082,8 +1091,10 @@ def handleNodeLoad(self, node, parent):
 
             importStarred = importStarred or scope.importStarred
 
-            if in_generators is not False:
-                in_generators = isinstance(scope, GeneratorScope)
+            if can_access_class_vars is not False:
+                can_access_class_vars = isinstance(
+                    scope, (TypeScope, GeneratorScope),
+                )
 
         if importStarred:
             from_list = []
@@ -1310,6 +1321,10 @@ def handleStringAnnotation(self, s, node, ref_lineno, ref_col_offset, err):
 
         self.handleNode(parsed_annotation, node)
 
+    def handle_annotation_always_deferred(self, annotation, parent):
+        fn = in_annotation(Checker.handleNode)
+        self.deferFunction(lambda: fn(self, annotation, parent))
+
     @in_annotation
     def handleAnnotation(self, annotation, node):
         if (
@@ -1326,8 +1341,7 @@ def handleAnnotation(self, annotation, node):
                 messages.ForwardAnnotationSyntaxError,
             ))
         elif self.annotationsFutureEnabled:
-            fn = in_annotation(Checker.handleNode)
-            self.deferFunction(lambda: fn(self, annotation, node))
+            self.handle_annotation_always_deferred(annotation, node)
         else:
             self.handleNode(annotation, node)
 
@@ -1902,7 +1916,10 @@ def YIELD(self, node):
     def FUNCTIONDEF(self, node):
         for deco in node.decorator_list:
             self.handleNode(deco, node)
-        self.LAMBDA(node)
+
+        with self._type_param_scope(node):
+            self.LAMBDA(node)
+
         self.addBinding(node, FunctionDefinition(node.name, node))
         # doctest does not process doctest within a doctest,
         # or in nested functions.
@@ -1951,7 +1968,10 @@ def LAMBDA(self, node):
 
         def runFunction():
             with self.in_scope(FunctionScope):
-                self.handleChildren(node, omit=['decorator_list', 'returns'])
+                self.handleChildren(
+                    node,
+                    omit=('decorator_list', 'returns', 'type_params'),
+                )
 
         self.deferFunction(runFunction)
 
@@ -1969,19 +1989,22 @@ def CLASSDEF(self, node):
         """
         for deco in node.decorator_list:
             self.handleNode(deco, node)
-        for baseNode in node.bases:
-            self.handleNode(baseNode, node)
-        for keywordNode in node.keywords:
-            self.handleNode(keywordNode, node)
-        with self.in_scope(ClassScope):
-            # doctest does not process doctest within a doctest
-            # classes within classes are processed.
-            if (self.withDoctest and
-                    not self._in_doctest() and
-                    not isinstance(self.scope, FunctionScope)):
-                self.deferFunction(lambda: self.handleDoctests(node))
-            for stmt in node.body:
-                self.handleNode(stmt, node)
+
+        with self._type_param_scope(node):
+            for baseNode in node.bases:
+                self.handleNode(baseNode, node)
+            for keywordNode in node.keywords:
+                self.handleNode(keywordNode, node)
+            with self.in_scope(ClassScope):
+                # doctest does not process doctest within a doctest
+                # classes within classes are processed.
+                if (self.withDoctest and
+                        not self._in_doctest() and
+                        not isinstance(self.scope, FunctionScope)):
+                    self.deferFunction(lambda: self.handleDoctests(node))
+                for stmt in node.body:
+                    self.handleNode(stmt, node)
+
         self.addBinding(node, ClassDefinition(node.name, node))
 
     def AUGASSIGN(self, node):
@@ -2155,3 +2178,21 @@ def _match_target(self, node):
         self.handleChildren(node)
 
     MATCHAS = MATCHMAPPING = MATCHSTAR = _match_target
+
+    @contextlib.contextmanager
+    def _type_param_scope(self, node):
+        with contextlib.ExitStack() as ctx:
+            if sys.version_info >= (3, 12):
+                ctx.enter_context(self.in_scope(TypeScope))
+                for param in node.type_params:
+                    self.handleNode(param, node)
+            yield
+
+    def TYPEVAR(self, node):
+        self.handleNodeStore(node)
+        self.handle_annotation_always_deferred(node.bound, node)
+
+    def TYPEALIAS(self, node):
+        self.handleNode(node.name, node)
+        with self._type_param_scope(node):
+            self.handle_annotation_always_deferred(node.value, node)

pyflakes/test/test_type_annotations.py

@@ -713,3 +713,70 @@ def f(*args: *Ts) -> None: ...
 
             def g(x: Shape[*Ts]) -> Shape[*Ts]: ...
         """)
+
+    @skipIf(version_info < (3, 12), 'new in Python 3.12')
+    def test_type_statements(self):
+        self.flakes("""
+            type ListOrSet[T] = list[T] | set[T]
+
+            def f(x: ListOrSet[str]) -> None: ...
+
+            type RecursiveType = int | list[RecursiveType]
+
+            type ForwardRef = int | C
+
+            type ForwardRefInBounds[T: C] = T
+
+            class C: pass
+        """)
+
+    @skipIf(version_info < (3, 12), 'new in Python 3.12')
+    def test_type_parameters_functions(self):
+        self.flakes("""
+            def f[T](t: T) -> T: return t
+
+            async def g[T](t: T) -> T: return t
+
+            def with_forward_ref[T: C](t: T) -> T: return t
+
+            def can_access_inside[T](t: T) -> T:
+                print(T)
+                return t
+
+            class C: pass
+        """)
+
+    @skipIf(version_info < (3, 12), 'new in Python 3.12')
+    def test_type_parameters_do_not_escape_function_scopes(self):
+        self.flakes("""
+            from x import g
+
+            @g(T)  # not accessible in decorators
+            def f[T](t: T) -> T: return t
+
+            T  # not accessible afterwards
+        """, m.UndefinedName, m.UndefinedName)
+
+    @skipIf(version_info < (3, 12), 'new in Python 3.12')
+    def test_type_parameters_classes(self):
+        self.flakes("""
+            class C[T](list[T]): pass
+
+            class UsesForward[T: Forward](list[T]): pass
+
+            class Forward: pass
+
+            class WithinBody[T](list[T]):
+                t = T
+        """)
+
+    @skipIf(version_info < (3, 12), 'new in Python 3.12')
+    def test_type_parameters_do_not_escape_class_scopes(self):
+        self.flakes("""
+            from x import g
+
+            @g(T)  # not accessible in decorators
+            class C[T](list[T]): pass
+
+            T  # not accessible afterwards
+        """, m.UndefinedName, m.UndefinedName)

tox.ini

@@ -8,7 +8,8 @@ setenv = PYFLAKES_ERROR_UNKNOWN=1
 commands =
     python --version --version
     python -m unittest discover pyflakes {posargs}
-    flake8 pyflakes setup.py
+    # TODO: remove factor selection after flake8 6.1
+    !py312: flake8 pyflakes setup.py
 
 [flake8]
 builtins = unicode