Fix positional-only parameters order

Author: Otto-AA

e2e_projects/my_lib/src/my_lib/__init__.py

@@ -104,9 +104,9 @@ def some_func(a, b: str = "111", c: Callable[[str], int] | None = None) -> int |
         return c(b)
     return None
 
-def func_with_star_clone(a, *, b, **kwargs): pass  # pragma: no mutate
-def func_with_star(a, *, b, **kwargs):
-    return a + b + len(kwargs)
+def func_with_star_clone(a, /, b, *, c, **kwargs): pass  # pragma: no mutate
+def func_with_star(a, /, b, *, c, **kwargs):
+    return a + b + c + len(kwargs)
 
 def func_with_arbitrary_args_clone(*args, **kwargs): pass  # pragma: no mutate
 def func_with_arbitrary_args(*args, **kwargs):

e2e_projects/my_lib/tests/test_my_lib.py

@@ -61,7 +61,7 @@ def test_that_signatures_are_preserved():
 
 def test_signature_functions_are_callable():
     assert some_func(True, c=lambda s: int(s), b="222") == 222
-    assert func_with_star(1, b=2, x='x', y='y', z='z') == 6
+    assert func_with_star(1, b=2, c=3, x='x', y='y', z='z') == 9
     assert func_with_arbitrary_args('a', 'b', foo=123, bar=456) == 4
 
 def test_signature_is_coroutine():

src/mutmut/file_mutation.py

@@ -258,10 +258,10 @@ def function_trampoline_arrangement(function: cst.FunctionDef, mutants: Iterable
 
 def create_trampoline_wrapper(function: cst.FunctionDef, mangled_name: str, class_name: str | None) -> cst.FunctionDef:
     args: list[cst.Element | cst.StarredElement] = []
-    for param in function.params.params:
-        args.append(cst.Element(param.name))
     for pos_only_param in function.params.posonly_params:
         args.append(cst.Element(pos_only_param.name))
+    for param in function.params.params:
+        args.append(cst.Element(param.name))
     if isinstance(function.params.star_arg, cst.Param):
         args.append(cst.StarredElement(function.params.star_arg.name))
 

tests/e2e/test_e2e_my_lib.py

@@ -77,6 +77,7 @@ def test_my_lib_result_snapshot():
                 "my_lib.x_some_func__mutmut_3": 1,
                 "my_lib.x_func_with_star__mutmut_1": 1,
                 "my_lib.x_func_with_star__mutmut_2": 1,
+                "my_lib.x_func_with_star__mutmut_3": 1,
                 "my_lib.x_func_with_arbitrary_args__mutmut_1": 1,
             }
         }

tests/test_mutation regression.py

@@ -1,6 +1,68 @@
 from inline_snapshot import snapshot
+import libcst as cst
 
-from mutmut.file_mutation import mutate_file_contents
+from mutmut.file_mutation import mutate_file_contents, create_trampoline_wrapper
+
+
+def _get_trampoline_wrapper(
+    source: str, mangled_name: str, class_name: str | None = None
+) -> str:
+    function = cst.ensure_type(cst.parse_statement(source), cst.FunctionDef)
+    trampoline = create_trampoline_wrapper(
+        function, mangled_name, class_name=class_name
+    )
+    return cst.Module([trampoline]).code.strip()
+
+
+def test_create_trampoline_wrapper_async_method():
+    source = "async def foo(a: str, b, *args, **kwargs) -> dict[str, int]: pass"
+
+    assert _get_trampoline_wrapper(source, "x_foo__mutmut") == snapshot("""\
+async def foo(a: str, b, *args, **kwargs) -> dict[str, int]:
+    args = [a, b, *args]
+    kwargs = {**kwargs}
+    return await _mutmut_trampoline(x_foo__mutmut_orig, x_foo__mutmut_mutants, args, kwargs, None)\
+""")
+
+
+def test_create_trampoline_wrapper_async_generator():
+    source = """
+async def foo():
+    for i in range(10):
+        yield i
+    """
+
+    assert _get_trampoline_wrapper(source, "x_foo__mutmut") == snapshot("""\
+async def foo():
+    args = []
+    kwargs = {}
+    async for i in _mutmut_trampoline(x_foo__mutmut_orig, x_foo__mutmut_mutants, args, kwargs, None):
+        yield i\
+""")
+
+
+def test_create_trampoline_wrapper_with_positionals_only_args():
+    source = "def foo(p1, p2=None, /, p_or_kw=None, *, kw): pass"
+
+    assert _get_trampoline_wrapper(source, "x_foo__mutmut") == snapshot("""\
+def foo(p1, p2=None, /, p_or_kw=None, *, kw):
+    args = [p1, p2, p_or_kw]
+    kwargs = {'kw': kw}
+    return _mutmut_trampoline(x_foo__mutmut_orig, x_foo__mutmut_mutants, args, kwargs, None)\
+""")
+
+
+def test_create_trampoline_wrapper_for_class_method():
+    source = "def foo(self, a, b): pass"
+
+    assert _get_trampoline_wrapper(
+        source, "x_foo__mutmut", class_name="Person"
+    ) == snapshot("""\
+def foo(self, a, b):
+    args = [a, b]
+    kwargs = {}
+    return _mutmut_trampoline(object.__getattribute__(self, 'x_foo__mutmut_orig'), object.__getattribute__(self, 'x_foo__mutmut_mutants'), args, kwargs, self)\
+""")
 
 
 def test_module_mutation():