fix: used needle_samples to find some issues

pyproject.toml

@@ -38,6 +38,7 @@ data_file = "$TOP/.coverage"
 
 [tool.black]
 force-exclude = "tests/.*_samples"
+skip_magic_trailing_comma = true
 
 [tool.mypy]
 exclude="tests/.*_samples"

pysource_minimize/_minimize.py

@@ -2,6 +2,8 @@
 import copy
 import os
 import sys
+from typing import List
+from typing import Union
 
 try:
     from ast import unparse
@@ -27,6 +29,18 @@ def is_block(nodes):
     )
 
 
+def arguments(
+    node: Union[ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda]
+) -> List[ast.arg]:
+    args = node.args
+    l = [*args.args, args.vararg, *args.kwonlyargs, args.kwarg]
+
+    if sys.version_info >= (3, 8):
+        l += args.posonlyargs
+
+    return [arg for arg in l if arg is not None]
+
+
 class Minimizer:
     def __init__(self, source, checker, progress_callback):
         self.checker = checker
@@ -246,6 +260,12 @@ def minimize_expr(self, node):
             if self.try_only(node, node.left):
                 self.minimize(node.left)
                 return
+
+            for comp in node.comparators:
+                if self.try_only(node, comp):
+                    self.minimize(comp)
+                    return
+
             self.minimize_lists(
                 (node.ops, node.comparators), (lambda _: None, self.minimize)
             )
@@ -254,20 +274,38 @@ def minimize_expr(self, node):
             self.try_only_minimize(node, node.value, node.slice)
 
         elif isinstance(node, ast.FormattedValue):
+            if (
+                isinstance(node.format_spec, ast.JoinedStr)
+                and len(node.format_spec.values) == 1
+                and self.try_only(node, node.format_spec.values[0])
+            ):
+                self.minimize(node.format_spec.values[0])
+                return
+
             self.try_none(node.format_spec)
             self.minimize_expr(node.value)
 
         elif isinstance(node, ast.JoinedStr):
+            if (
+                len(node.values) == 1
+                and isinstance(node.values[0], ast.FormattedValue)
+                and self.try_only(node, node.values[0].value)
+            ):
+                self.minimize(node.values[0].value)
+                return
+
             self.minimize(node.values)
             # todo minimize values
 
         elif isinstance(node, ast.Slice):
             self.try_only_minimize(node, node.lower, node.upper, node.step)
         elif isinstance(node, ast.Lambda):
+
             if self.try_only_minimize(node, node.body):
                 return
 
-            self.minimize_args(node.args)
+            if self.minimize_args_of(node):
+                return
 
         elif isinstance(node, ast.UnaryOp):
             self.try_only_minimize(node, node.operand)
@@ -338,31 +376,30 @@ def minimize_expr(self, node):
             node, (ast.ListComp, ast.SetComp, ast.GeneratorExp, ast.DictComp)
         ):
             for gen in node.generators:
+                if self.try_only(node, gen.target):
+                    self.minimize_expr(gen.target)
+                    return
+
                 if self.try_only(node, gen.iter):
                     self.minimize_expr(gen.iter)
                     return
 
-            if isinstance(node, ast.DictComp):
-                if self.try_only(node, node.key):
-                    self.minimize_expr(node.key)
-                    return
+                for if_ in gen.ifs:
+                    if self.try_only(node, if_):
+                        self.minimize_expr(if_)
+                        return
 
-                if self.try_only(node, node.value):
-                    self.minimize_expr(node.value)
+            if isinstance(node, ast.DictComp):
+                if self.try_only_minimize(node, node.key, node.value):
                     return
-
-                self.minimize_expr(node.key)
-                self.minimize_expr(node.value)
             else:
-                if self.try_only(node, node.elt):
-                    self.minimize_expr(node.elt)
+                if self.try_only_minimize(node, node.elt):
                     return
 
-                self.minimize_expr(node.elt)
             self.minimize_list(node.generators, self.minimize_comprehension, 1)
 
         elif isinstance(node, ast.NamedExpr):
-            self.try_only_minimize(node, node.value)
+            self.try_only_minimize(node, node.target, node.value)
         else:
             raise TypeError(node)  # Expr
 
@@ -410,7 +447,19 @@ def minimize_pattern(pattern):
 
             minimize_pattern(c.pattern)
 
-    def minimize_args(self, args):
+    def minimize_args_of(self, func):
+        args = func.args
+
+        for child in [
+            *[arg.annotation for arg in arguments(func)],
+            *func.args.defaults,
+            *func.args.kw_defaults,
+            getattr(func, "returns", None),
+        ]:
+            if child is not None and self.try_only(func, child):
+                self.minimize(child)
+                return True
+
         def minimize_arg(arg: ast.arg):
             if arg.annotation is not None and not self.try_none(arg.annotation):
                 self.minimize(arg.annotation)
@@ -435,6 +484,8 @@ def minimize_arg(arg: ast.arg):
         if args.kwarg is not None and not self.try_none(args.kwarg):
             minimize_arg(args.kwarg)
 
+        return False
+
     def minimize_stmt(self, node):
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
             if self.try_only_minimize(node, node.decorator_list):
@@ -460,7 +511,8 @@ def minimize_stmt(self, node):
                 if self.try_only(node, node.body):
                     return
 
-            self.minimize_args(node.args)
+            if self.minimize_args_of(node):
+                return
             if sys.version_info >= (3, 12):
                 self.minimize_list(node.type_params, self.minimize_type_param)
 
@@ -499,26 +551,30 @@ def minimize_stmt(self, node):
             self.try_only_minimize(node, node.value)
 
         elif isinstance(node, ast.Delete):
+            if len(node.targets) == 1 and self.try_only(node, node.targets[0]):
+                self.minimize(node.targets[0])
+                return
+
             self.minimize_list(node.targets, self.minimize, 1)
 
         elif isinstance(node, ast.Assign):
             self.try_only_minimize(node, node.value, node.targets)
 
-            # todo minimize targets
-
         elif isinstance(node, ast.AugAssign):
-            self.minimize(node.target)
-            self.try_only_minimize(node, node.value)
-            # todo minimize target
+            self.try_only_minimize(node, node.target, node.value)
 
         elif isinstance(node, ast.AnnAssign):
+
             if node.value is None or not self.try_node(
                 node, ast.Assign(targets=[node.target], value=node.value)
             ):
-                self.try_only_minimize(node, node.value, node.annotation)
-            # todo minimize target
+                self.try_only_minimize(node, node.target, node.value, node.annotation)
 
         elif isinstance(node, (ast.For, ast.AsyncFor)):
+            if self.try_only(node, node.target):
+                self.minimize(node.target)
+                return
+
             self.minimize_list(node.body, self.minimize_stmt)
             body = self.get_ast(node)
             if not any(
@@ -548,21 +604,42 @@ def minimize_stmt(self, node):
             self.try_only_minimize(node, node.test, node.body, node.orelse)
 
         elif isinstance(node, (ast.With, ast.AsyncWith)):
+
+            if self.try_only_minimize(node, node.body):
+                return
+
             for item in node.items:
                 if self.try_only(node, item.context_expr):
                     self.minimize(item.context_expr)
                     return
 
+                if item.optional_vars is not None and self.try_only(
+                    node, item.optional_vars
+                ):
+                    self.minimize(item.optional_vars)
+                    return
+
             def minimize_item(item: ast.withitem):
                 self.minimize(item.context_expr)
                 self.minimize_optional(item.optional_vars)
 
             self.minimize_list(node.items, minimize_item, minimal=1)
 
-            self.minimize_list(node.body, self.minimize_stmt)
-
         elif py310 and isinstance(node, ast.Match):
-            self.minimize(node.subject)
+            if self.try_only_minimize(node, node.subject):
+                return
+
+            for case_ in node.cases:
+                for e in [case_.guard, case_.body]:
+                    if e is not None and self.try_only(node, e):
+                        self.minimize(e)
+                        return
+
+                if isinstance(case_.pattern, ast.MatchValue):
+                    if self.try_only(node, case_.pattern.value):
+                        self.minimize(case_.pattern.value)
+                        return
+
             self.minimize_list(node.cases, self.minimize_match_case, 1)
 
         elif isinstance(node, ast.Raise):

tests/conftest.py

@@ -3,24 +3,23 @@
 import pytest
 
 
-@pytest.fixture(params=range(100))
+@pytest.fixture(params=range(0))
 def seed():
     return random.randrange(0, 100000000)
 
 
-
 def pytest_addoption(parser, pluginmanager):
     parser.addoption(
-        "--generate-samples",action="store_true"
- ,       help="Config file to use, defaults to %(default)s",
+        "--generate-samples",
+        action="store_true",
+        help="Config file to use, defaults to %(default)s",
     )
 
+
 def pytest_sessionfinish(session, exitstatus):
-    if exitstatus==0 and session.config.option.generate_samples:
+    if exitstatus == 0 and session.config.option.generate_samples:
         from .test_needle import generate_needle
 
         generate_needle()
-
 
     # teardown_stuff
-

tests/needle_samples/0766377bba7e1183bc6b60a00126dc314ebe86a1524778bd0f8282f9efe3f50c.py

@@ -0,0 +1,2 @@
+def name_3() -> needle_17597:
+    pass

tests/needle_samples/096c69226f40ed288f009989ba0691682514f4d2e38e7ae2231dd9b71d66f8bd.py

@@ -0,0 +1 @@
+needle_17597 ^= name_4

tests/needle_samples/0c5dc4b2ba515d549d7a49dc43138a6db157ad30c60ab250811e0e3ced2b356b.py

@@ -0,0 +1 @@
+lambda *, name_5=needle_17597: name_5

tests/needle_samples/135a1e0ef5d277ee4b3f1f222513c19b0c0024f2d4231f7c963928c4a1ac21bc.py

@@ -0,0 +1,3 @@
+match needle_17597:
+    case name_1.name_3:
+        pass

tests/needle_samples/1dc8d6fa0614ac3a102613c35c1e8cc6268187e08d1a6704b8e46f4031b18a2a.py

@@ -0,0 +1 @@
+name_2 <= needle_17597

tests/needle_samples/2c9dd5384c1bf4c07d7030826112e071e40bb113e23db1bd7cb7ca03f4f01d35.py

@@ -0,0 +1 @@
+f'{needle_17597!s}'

tests/needle_samples/397c83ef84012357cd329f5be55a85551de8c87f85dfd228d3f414c7dacfbfc0.py

@@ -0,0 +1,2 @@
+async def name_0(*, name_2=needle_17597):
+    pass

tests/needle_samples/3c81be9d7688f7e002c561de7c8221d66b73f32d97dc26a965662f9b23d1930b.py

@@ -0,0 +1 @@
+[name_5 for needle_17597 in name_3]

tests/needle_samples/44bf672ae0eb3d411f6386f580d2e36f365501f64f9faba721bf366f6cdedd7b.py

@@ -0,0 +1,3 @@
+match name_3:
+    case needle_17597.name_5:
+        pass

tests/needle_samples/5f3166733173433a642358d6640d91a2d7d0e1d25d5d8e92348a3efa54819566.py

@@ -0,0 +1,2 @@
+def name_5(name_4: needle_17597, /):
+    pass

tests/needle_samples/7f4a88311276414dc959202b2ba5540e538f0bfc24f940706d4cb4c4f4d2ce60.py

@@ -0,0 +1 @@
+f'{1!s:{needle_17597}}'

tests/needle_samples/9bc324f232f61f3df1bcd711b0b973bedd6f4cae794bb24dfce5f1c53cca8fa6.py

@@ -0,0 +1 @@
+(name_3 for name_1 in name_5 if needle_17597)

tests/needle_samples/b4d76bcfa10ca9179203b6581a55d03f8bfc65f38f3ac64ebb231818048cf529.py

@@ -0,0 +1,2 @@
+with name_0 as needle_17597:
+    pass

tests/needle_samples/bf24417717af32f5b6999aab2e9aa32fca703d3d648914dc192c3e385fef7e40.py

@@ -0,0 +1 @@
+needle_17597: name_1

tests/needle_samples/cb57cbdece6733a706bd490f1491a69193d7830d53935621af8829260285aca3.py

@@ -0,0 +1 @@
+del needle_17597

tests/needle_samples/d3b703cdc529a83dbd9be151af57c4cb8ee379053b012403ad29262409628326.py

@@ -0,0 +1,2 @@
+with name_4:
+    needle_17597

tests/needle_samples/d995f259dbef7f14c446109fbd9dc61bb0f7cacb75d911392afafd95a2d3e473.py

@@ -0,0 +1 @@
+(needle_17597 := name_0)

tests/needle_samples/e5d74f55a84871ca3b93c4d143c0d73f4dbd5152be473ebe948afc6cb423e8be.py

@@ -0,0 +1,2 @@
+for needle_17597 in name_5:
+    pass