[3.15] Detect PEP 798 unpacking in comprehension values

Author: netromdk

README.rst

@@ -141,21 +141,22 @@ Features detected include v2/v3 ``print expr`` and ``print(expr)``, ``long``, f-
 asynchronous comprehensions, ``await`` in comprehensions, asynchronous ``for``-loops, boolean
 constants, named expressions, keyword-only parameters, positional-only parameters, ``nonlocal``,
 ``yield from``, exception context cause (``raise .. from ..``), ``except*``, ``set`` literals,
-``set`` comprehensions, ``dict`` comprehensions, infix matrix multiplication, ``"..".format(..)``,
-imports (``import X``, ``from X import Y``, ``from X import *``), function calls wrt. name and
-kwargs, ``strftime`` + ``strptime`` directives used, function and variable annotations (also
-``Final`` and ``Literal``), ``continue`` in ``finally`` block, modular inverse ``pow()``, array
-typecodes, codecs error handler names, encodings, ``%`` formatting and directives for bytes and
-bytearray, ``with`` statement, asynchronous ``with`` statement, multiple context expressions in a
-``with`` statement, multiple context expressions in a ``with`` statement grouped with parenthesis,
-unpacking assignment, generalized unpacking, ellipsis literal (``...``) out of slices, dictionary
-union (``{..}  | {..}``), dictionary union merge (``a = {..}; a |= {..}``), builtin generic type
-annotations (``list[str]``), function decorators, class decorators, relaxed decorators,
-``metaclass`` class keyword, pattern matching with ``match``, union types written as ``X | Y``, type
-alias statements (``type X = SomeType``), type alias statements with lambdas/comprehensions in class
-scopes, generic classes (``class C[T]: ...``), and template string literals (``t'{var}'``). It tries
-to detect and ignore user-defined functions, classes, arguments, and variables with names that clash
-with library-defined symbols.
+``set`` comprehensions, ``dict`` comprehensions, unpacking in comprehension value expressions (``[*x
+for x in range(10)]``), infix matrix multiplication, ``"..".format(..)``, imports (``import X``,
+``from X import Y``, ``from X import *``), function calls wrt. name and kwargs, ``strftime`` +
+``strptime`` directives used, function and variable annotations (also ``Final`` and ``Literal``),
+``continue`` in ``finally`` block, modular inverse ``pow()``, array typecodes, codecs error handler
+names, encodings, ``%`` formatting and directives for bytes and bytearray, ``with`` statement,
+asynchronous ``with`` statement, multiple context expressions in a ``with`` statement, multiple
+context expressions in a ``with`` statement grouped with parenthesis, unpacking assignment,
+generalized unpacking, ellipsis literal (``...``) out of slices, dictionary union (``{..}  |
+{..}``), dictionary union merge (``a = {..}; a |= {..}``), builtin generic type annotations
+(``list[str]``), function decorators, class decorators, relaxed decorators, ``metaclass`` class
+keyword, pattern matching with ``match``, union types written as ``X | Y``, type alias statements
+(``type X = SomeType``), type alias statements with lambdas/comprehensions in class scopes, generic
+classes (``class C[T]: ...``), and template string literals (``t'{var}'``). It tries to detect and
+ignore user-defined functions, classes, arguments, and variables with names that clash with
+library-defined symbols.
 
 Caveats
 =======

tests/lang.py

@@ -1173,6 +1173,19 @@ def lower_upper(template):
     visitor = self.visit("f'hello'")
     self.assertFalse(visitor.template_string_literal())
 
+  @VerminTest.skipUnlessVersion(3, 15)
+  def test_unpacking_in_comprehension(self):
+    visitor = self.visit("[*x for x in range(10)]")
+    self.assertTrue(visitor.unpacking_in_comprehension())
+    self.assertOnlyIn((3, 15), visitor.minimum_versions())
+
+    visitor = self.visit("{*x for x in range(10)}")
+    self.assertTrue(visitor.unpacking_in_comprehension())
+    self.assertOnlyIn((3, 15), visitor.minimum_versions())
+
+    visitor = self.visit("[x for x in range(10)]")
+    self.assertFalse(visitor.unpacking_in_comprehension())
+
   @VerminTest.skipUnlessVersion(3, 5)
   def test_bytes_format(self):
     visitor = self.visit("b'%x' % 10")

vermin/source_state.py

@@ -127,6 +127,12 @@ def __init__(self, config, path=None, source=None):
     # `t'text {var}'`
     self.template_string_literal = False
 
+    # Track depth of nested comprehension value expressions (PEP 798).
+    self.comprehension_depth = 0
+
+    # `*x` unpacking in comprehension value expressions (PEP 798).
+    self.unpacking_in_comprehension = False
+
     # Imported members of modules, like "exc_clear" of "sys".
     self.import_mem_mod = {}
 

vermin/source_visitor.py

@@ -276,6 +276,9 @@ def metaclass_class_keyword(self):
   def generic_class(self):
     return self.__s.generic_class
 
+  def unpacking_in_comprehension(self):
+    return self.__s.unpacking_in_comprehension
+
   def __get_source_line(self, line, col=0):
     if self.__s.source is None:
       return None  # pragma: no cover
@@ -529,6 +532,9 @@ def minimum_versions(self):
     if self.generic_class():
       mins = self.__add_versions_entity(mins, (None, (3, 12)), "generic class `class C[T]: ...`")
 
+    if self.unpacking_in_comprehension():
+      mins = self.__add_versions_entity(mins, (None, (3, 15)),
+                                        "unpacking in comprehension (PEP 798)")
     for directive in self.strftime_directives():
       if directive in STRFTIME_REQS:
         vers = STRFTIME_REQS[directive]
@@ -1080,6 +1086,10 @@ def visit_Starred(self, node):
     if isinstance(node.ctx, ast.Store):
       self.__s.unpacking_assignment = True
       self.__vvprint("unpacking assignment", versions=[None, (3, 0)])
+    elif self.__s.comprehension_depth > 0 and isinstance(node.ctx, ast.Load):
+      # PEP 798: starred expression in comprehension value expression (3.15+).
+      self.__s.unpacking_in_comprehension = True
+      self.__vvprint("unpacking in comprehension (PEP 798)", versions=[None, (3, 15)])
     self.generic_visit(node)
 
   def __check_generalized_unpacking(self, node):
@@ -2062,30 +2072,38 @@ def __handle_comprehensions(self, comps):
     return user_defs_copy
 
   def visit_ListComp(self, node):
+    self.__s.comprehension_depth += 1
     user_defs_copy = self.__handle_comprehensions(node.generators)
     self.generic_visit(node)
     self.__s.user_defs = user_defs_copy
+    self.__s.comprehension_depth -= 1
 
   def visit_SetComp(self, node):
+    self.__s.comprehension_depth += 1
     self.__s.set_comp = True
     self.__vvprint("set comprehensions", versions=[(2, 7), (3, 0)])
 
     user_defs_copy = self.__handle_comprehensions(node.generators)
     self.generic_visit(node)
     self.__s.user_defs = user_defs_copy
+    self.__s.comprehension_depth -= 1
 
   def visit_GeneratorExp(self, node):
+    self.__s.comprehension_depth += 1
     user_defs_copy = self.__handle_comprehensions(node.generators)
     self.generic_visit(node)
     self.__s.user_defs = user_defs_copy
+    self.__s.comprehension_depth -= 1
 
   def visit_DictComp(self, node):
+    self.__s.comprehension_depth += 1
     self.__s.dict_comp = True
     self.__vvprint("dict comprehensions", versions=[(2, 7), (3, 0)])
 
     user_defs_copy = self.__handle_comprehensions(node.generators)
     self.generic_visit(node)
     self.__s.user_defs = user_defs_copy
+    self.__s.comprehension_depth -= 1
 
   def visit_comprehension(self, node):
     if hasattr(node, "is_async") and node.is_async == 1: