posonly args: bugfixes & address PR comments

Cython/Compiler/Nodes.py

@@ -3929,7 +3929,7 @@ class DefNodeWrapper(FuncDefNode):
                 if arg.pos_only:
                     if i == last_required_posonly_arg:
                         code.put_goto(argtuple_error_label)
-                    if i == last_required_arg:
+                    elif i == last_required_arg:
                         code.putln('break;')
                     continue
                 if arg.default:
@@ -4014,12 +4014,17 @@ class DefNodeWrapper(FuncDefNode):
             pos_arg_count = "used_pos_args"
         else:
             pos_arg_count = "kwd_pos_args"
+        if num_pos_only_args > 0 and num_pos_only_args < len(all_args):
+            values_array = 'values + %d' % (num_pos_only_args)
+        else:
+            values_array = 'values'
         code.globalstate.use_utility_code(
             UtilityCode.load_cached("ParseKeywords", "FunctionArguments.c"))
-        code.putln('if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) %s' % (
+        code.putln('if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, %s, %s, "%s") < 0)) %s' % (
             Naming.kwds_cname,
             Naming.pykwdlist_cname,
             self.starstar_arg and self.starstar_arg.entry.cname or '0',
+            values_array,
             pos_arg_count,
             self.name,
             code.error_goto(self.pos)))
@@ -4028,12 +4033,19 @@ class DefNodeWrapper(FuncDefNode):
     def generate_optional_kwonly_args_unpacking_code(self, all_args, code):
         optional_args = []
         first_optional_arg = -1
+        num_posonly_args = 0
         for i, arg in enumerate(all_args):
+            if arg.pos_only:
+                num_posonly_args += 1
             if not arg.kw_only or not arg.default:
                 continue
             if not optional_args:
                 first_optional_arg = i
             optional_args.append(arg.name)
+        if num_posonly_args > 0:
+            posonly_correction = '-%d' % num_posonly_args
+        else:
+            posonly_correction = ''
         if optional_args:
             if len(optional_args) > 1:
                 # if we receive more than the named kwargs, we either have **kwargs
@@ -4049,8 +4061,8 @@ class DefNodeWrapper(FuncDefNode):
             else:
                 code.putln('if (kw_args == 1) {')
                 code.putln('const Py_ssize_t index = %d;' % first_optional_arg)
-            code.putln('PyObject* value = __Pyx_PyDict_GetItemStr(%s, *%s[index]);' % (
-                Naming.kwds_cname, Naming.pykwdlist_cname))
+            code.putln('PyObject* value = __Pyx_PyDict_GetItemStr(%s, *%s[index%s]);' % (
+                Naming.kwds_cname, Naming.pykwdlist_cname, posonly_correction))
             code.putln('if (value) { values[index] = value; kw_args--; }')
             if len(optional_args) > 1:
                 code.putln('}')

tests/compile/posonly.pyx

-# mode: compile
-# tag: posonly
-
-# TODO: remove posonly tag before merge (and maybe remove this test,
-#       since it seems covered by the runs/ test)
-
-def test(x, y, z=42, /, w=43):
-    pass
-
-def test2(x, y, /):
-    pass
-
-def test3(x, /, z):
-    pass
-
-def test4(x, /, z, *, w):
-    pass

tests/errors/posonly.pyx

+# mode: error
+# tag: posonly
+
+def f(a, b = 5, /, c):
+    pass
+
+def f(a = 5, b, /, c):
+    pass
+
+def f(a = 5, b, /):
+    pass
+
+def f(a, /, a):
+    pass
+
+def f(a, /, *, a):
+    pass
+
+#def f(a, b/2, c): #D
+#    pass
+
+#def f(*args, /): #D
+#    pass
+
+#def f(*args, a, /):
+#    pass
+
+#def f(**kwargs, /):
+#    pass
+
+#def f(/, a = 1): # D
+#    pass
+
+#def f(/, a):
+#    pass
+
+#def f(/):
+#    pass
+
+#def f(*, a, /):
+#    pass
+
+#def f(*, /, a):
+#    pass
+
+#def f(a, /, c, /):
+#    pass
+
+#def f(a, /, c, /, d):
+#    pass
+
+#def f(a, /, c, /, d, *, e):
+#    pass
+
+#def f(a, *, c, /, d, e):
+#    pass
+
+def test_invalid_syntax_lambda(self):
+    lambda a, b = 5, /, c: None
+    lambda a = 5, b, /, c: None
+    lambda a = 5, b, /: None
+    lambda a, /, a: None
+    lambda a, /, *, a: None
+#    lambda *args, /: None
+#    lambda *args, a, /: None
+#    lambda **kwargs, /: None
+#    lambda /, a = 1: None
+#    lambda /, a: None
+#    lambda /: None
+#    lambda *, a, /: None
+#    lambda *, /, a: None
+
+async def f(a, b = 5, /, c):
+    pass
+
+#def test_multiple_seps(a,/,b,/):
+#    pass
+
+_ERRORS = u"""
+4:19: Non-default argument following default argument
+7:13: Non-default argument following default argument
+7:19: Non-default argument following default argument
+10:13: Non-default argument following default argument
+13:6: Previous declaration is here
+13:12: 'a' redeclared
+16:6: Previous declaration is here
+16:15: 'a' redeclared
+59:24: Non-default argument following default argument
+60:18: Non-default argument following default argument
+60:24: Non-default argument following default argument
+61:18: Non-default argument following default argument
+62:11: Previous declaration is here
+62:17: 'a' redeclared
+63:11: Previous declaration is here
+63:20: 'a' redeclared
+73:25: Non-default argument following default argument
+"""
+
+
+
+
+

tests/errors/posonly2.pyx

+# mode: error
+# tag: posonly
+
+def f(a, b/2, c):
+    pass
+
+_ERRORS = u"""
+4:11: Syntax error in Python function argument list
+"""

tests/errors/posonly3.pyx

+# mode: error
+# tag: posonly
+
+def f(*args, /):
+    pass
+
+def f(*args, a, /):
+    pass
+
+
+_ERRORS = u"""
+4:13: Expected ')', found '/'
+"""

tests/errors/posonly4.pyx

+# mode: error
+# tag: posonly
+
+def f(/, a = 1):
+    pass
+
+_ERRORS = u"""
+4:6: Got zero positional-only arguments despite presence of positional-only specifier '/'
+"""

tests/errors/posonly5.pyx

+# mode: error
+# tag: posonly
+
+def test_multiple_seps(a,/,b,/):
+    pass
+
+_ERRORS = u"""
+4:29: Expected ')', found '/'
+"""
+
+

tests/run/posonly.pyx

@@ -4,23 +4,8 @@
 # TODO: remove posonly tag before merge
 
 import cython
-
-# TODO: add the test below to an 'error' test
-#def test_invalid_syntax_errors():
-#    def f(a, b = 5, /, c): pass
-#    def f(a = 5, b, /, c): pass
-#    def f(a = 5, b, /): pass
-#    def f(*args, /): pass
-#    def f(*args, a, /): pass
-#    def f(**kwargs, /): pass
-#    def f(/, a = 1): pass
-#    def f(/, a): pass
-#    def f(/): pass
-#    def f(*, a, /): pass
-#    def f(*, /, a): pass
-#    def f(a, /, a): pass
-#    def f(a, /, *, a): pass
-#    def f(a, b/2, c): pass
+import sys
+import pickle
 
 def test_optional_posonly_args1(a, b=10, /, c=100):
     """
@@ -58,27 +43,58 @@ def test_optional_posonly_args2(a=1, b=10, /, c=100):
     """
     return a + b + c
 
-# TODO: remove the test below?  would need to hard-code the function with > 255 posonly args
-#def test_syntax_for_many_positional_only():
-#    # more than 255 positional only arguments, should compile ok
-#    fundef = "def f(%s, /):\n  pass\n" % ', '.join('i%d' % i for i in range(300))
-#    compile(fundef, "<test>", "single")
+# TODO: this causes a line that is too long for old versions of Clang
+#def many_args(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20,a21,
+#              a22,a23,a24,a25,a26,a27,a28,a29,a30,a31,a32,a33,a34,a35,a36,a37,a38,a39,a40,
+#              a41,a42,a43,a44,a45,a46,a47,a48,a49,a50,a51,a52,a53,a54,a55,a56,a57,a58,a59,
+#              a60,a61,a62,a63,a64,a65,a66,a67,a68,a69,a70,a71,a72,a73,a74,a75,a76,a77,a78,
+#              a79,a80,a81,a82,a83,a84,a85,a86,a87,a88,a89,a90,a91,a92,a93,a94,a95,a96,a97,
+#              a98,a99,a100,a101,a102,a103,a104,a105,a106,a107,a108,a109,a110,a111,a112,
+#              a113,a114,a115,a116,a117,a118,a119,a120,a121,a122,a123,a124,a125,a126,a127,
+#              a128,a129,a130,a131,a132,a133,a134,a135,a136,a137,a138,a139,a140,a141,a142,
+#              a143,a144,a145,a146,a147,a148,a149,a150,a151,a152,a153,a154,a155,a156,a157,
+#              a158,a159,a160,a161,a162,a163,a164,a165,a166,a167,a168,a169,a170,a171,a172,
+#              a173,a174,a175,a176,a177,a178,a179,a180,a181,a182,a183,a184,a185,a186,a187,
+#              a188,a189,a190,a191,a192,a193,a194,a195,a196,a197,a198,a199,a200,a201,a202,
+#              a203,a204,a205,a206,a207,a208,a209,a210,a211,a212,a213,a214,a215,a216,a217,
+#              a218,a219,a220,a221,a222,a223,a224,a225,a226,a227,a228,a229,a230,a231,a232,
+#              a233,a234,a235,a236,a237,a238,a239,a240,a241,a242,a243,a244,a245,a246,a247,
+#              a248,a249,a250,a251,a252,a253,a254,a255,a256,a257,a258,a259,a260,a261,a262,
+#              a263,a264,a265,a266,a267,a268,a269,a270,a271,a272,a273,a274,a275,a276,a277,
+#              a278,a279,a280,a281,a282,a283,a284,a285,a286,a287,a288,a289,a290,a291,a292,
+#              a293,a294,a295,a296,a297,a298,a299,/,b,c=42,*,d):
+#    """
+#    >>> many_args(*range(299),b=1,c=2,d=3)
+#    (298, 1, 2, 3)
+#    >>> many_args(*range(299),b=1,d=3)
+#    (298, 1, 42, 3)
+#    >>> many_args(*range(300),d=3)
+#    (298, 299, 42, 3)
+#    """
+#    return (a299, b, c, d)
 
-# TODO: remove the test below?  doesn't seem relevant to Cython implementation
-#def test_pos_only_definition(self):
-#    def f(a, b, c, /, d, e=1, *, f, g=2):
-#        pass
-#
-#    self.assertEqual(2, f.__code__.co_argcount)  # 2 "standard args"
-#    self.assertEqual(3, f.__code__.co_posonlyargcount)
-#    self.assertEqual((1,), f.__defaults__)
-#
-#    def f(a, b, c=1, /, d=2, e=3, *, f, g=4):
-#        pass
-#
-#    self.assertEqual(2, f.__code__.co_argcount)  # 2 "standard args"
-#    self.assertEqual(3, f.__code__.co_posonlyargcount)
-#    self.assertEqual((1, 2, 3), f.__defaults__)
+#TODO: update this test for Python 3.8
+@cython.binding(True)
+def func_introspection1(a, b, c, /, d, e=1, *, f, g=2):
+    """
+    >>> if sys.version_info[0] < 3:
+    ...     assert func_introspection2.__code__.co_argcount == 7
+    ... else:
+    ...     assert func_introspection2.__code__.co_argcount == 5
+    >>> func_introspection1.__defaults__
+    (1,)
+    """
+
+@cython.binding(True)
+def func_introspection2(a, b, c=1, /, d=2, e=3, *, f, g=4):
+    """
+    >>> if sys.version_info[0] < 3:
+    ...     assert func_introspection2.__code__.co_argcount == 7
+    ... else:
+    ...     assert func_introspection2.__code__.co_argcount == 5
+    >>> func_introspection2.__defaults__
+    (1, 2, 3)
+    """
 
 def test_pos_only_call_via_unpacking(a, b, /):
     """
@@ -89,30 +105,33 @@ def test_pos_only_call_via_unpacking(a, b, /):
 
 def test_use_positional_as_keyword1(a, /):
     """
+    >>> test_use_positional_as_keyword1(1)
     >>> test_use_positional_as_keyword1(a=1)
     Traceback (most recent call last):
     TypeError: test_use_positional_as_keyword1() takes no keyword arguments
     """
-    pass
 
 def test_use_positional_as_keyword2(a, /, b):
     """
+    >>> test_use_positional_as_keyword2(1, 2)
+    >>> test_use_positional_as_keyword2(1, b=2)
     >>> test_use_positional_as_keyword2(a=1, b=2)
     Traceback (most recent call last):
     TypeError: test_use_positional_as_keyword2() takes exactly 2 positional arguments (0 given)
     """
-    pass
 
 def test_use_positional_as_keyword3(a, b, /):
     """
+    >>> test_use_positional_as_keyword3(1, 2)
     >>> test_use_positional_as_keyword3(a=1, b=2)
     Traceback (most recent call last):
     TypeError: test_use_positional_as_keyword3() takes exactly 2 positional arguments (0 given)
     """
-    pass
 
 def test_positional_only_and_arg_invalid_calls(a, b, /, c):
     """
+    >>> test_positional_only_and_arg_invalid_calls(1, 2, 3)
+    >>> test_positional_only_and_arg_invalid_calls(1, 2, c=3)
     >>> test_positional_only_and_arg_invalid_calls(1, 2)
     Traceback (most recent call last):
     TypeError: test_positional_only_and_arg_invalid_calls() takes exactly 3 positional arguments (2 given)
@@ -123,7 +142,6 @@ def test_positional_only_and_arg_invalid_calls(a, b, /, c):
     Traceback (most recent call last):
     TypeError: test_positional_only_and_arg_invalid_calls() takes exactly 3 positional arguments (4 given)
     """
-    pass
 
 def test_positional_only_and_optional_arg_invalid_calls(a, b, /, c=3):
     """
@@ -138,7 +156,32 @@ def test_positional_only_and_optional_arg_invalid_calls(a, b, /, c=3):
     Traceback (most recent call last):
     TypeError: test_positional_only_and_optional_arg_invalid_calls() takes at most 3 positional arguments (4 given)
     """
-    pass
+
+def test_positional_only_and_kwonlyargs_invalid_calls(a, b, /, c, *, d, e):
+    """
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2, 3, d=1, e=2)
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2, 3, e=2)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() needs keyword-only argument d
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2, 3)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() needs keyword-only argument d
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() takes exactly 3 positional arguments (2 given)
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() takes exactly 3 positional arguments (1 given)
+    >>> test_positional_only_and_kwonlyargs_invalid_calls()
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() takes exactly 3 positional arguments (0 given)
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2, 3, 4, 5, 6, d=7, e=8)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() takes exactly 3 positional arguments (6 given)
+    >>> test_positional_only_and_kwonlyargs_invalid_calls(1, 2, 3, d=1, e=4, f=56)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_kwonlyargs_invalid_calls() got an unexpected keyword argument 'f'
+    """
 
 def test_positional_only_invalid_calls(a, b, /):
     """
@@ -153,7 +196,6 @@ def test_positional_only_invalid_calls(a, b, /):
     Traceback (most recent call last):
     TypeError: test_positional_only_invalid_calls() takes exactly 2 positional arguments (3 given)
     """
-    pass
 
 def test_positional_only_with_optional_invalid_calls(a, b=2, /):
     """
@@ -165,7 +207,6 @@ def test_positional_only_with_optional_invalid_calls(a, b=2, /):
     Traceback (most recent call last):
     TypeError: test_positional_only_with_optional_invalid_calls() takes at most 2 positional arguments (3 given)
     """
-    pass
 
 def test_no_standard_args_usage(a, b, /, *, c):
     """
@@ -174,10 +215,9 @@ def test_no_standard_args_usage(a, b, /, *, c):
     Traceback (most recent call last):
     TypeError: test_no_standard_args_usage() takes exactly 2 positional arguments (1 given)
     """
-    pass
 
 #def test_change_default_pos_only():
-# TODO: probably remove this, since we have no __defaults__ in Cython?
+# TODO: probably remove this, since  __defaults__ is not writable in Cython?
 #    """
 #    >>> test_change_default_pos_only()
 #    True
@@ -212,64 +252,60 @@ def test_lambdas():
     x = lambda a, b, /, : a + b
     print(x(1, 2))
 
-
-#TODO: need to implement this in the 'error' test
-#def test_invalid_syntax_lambda(self):
-#    lambda a, b = 5, /, c: None
-#    lambda a = 5, b, /, c: None
-#    lambda a = 5, b, /: None
-#    lambda a, /, a: None
-#    lambda a, /, *, a: None
-#    lambda *args, /: None
-#    lambda *args, a, /: None
-#    lambda **kwargs, /: None
-#    lambda /, a = 1: None
-#    lambda /, a: None
-#    lambda /: None
-#    lambda *, a, /: None
-#    lambda *, /, a: None
-
-class Example:
-    def f(self, a, b, /):
-        return a, b
-
-def test_posonly_methods():
+class TestPosonlyMethods(object):
     """
-    >>> Example().f(1,2)
+    >>> TestPosonlyMethods().f(1,2)
     (1, 2)
-    >>> Example.f(Example(), 1, 2)
+    >>> TestPosonlyMethods.f(TestPosonlyMethods(), 1, 2)
     (1, 2)
     >>> try:
-    ...     Example.f(1,2)
+    ...     TestPosonlyMethods.f(1,2)
     ... except TypeError:
     ...    print("Got type error")
     Got type error
-    >>> Example().f(1, b=2)
+    >>> TestPosonlyMethods().f(1, b=2)
     Traceback (most recent call last):
     TypeError: f() takes exactly 3 positional arguments (2 given)
     """
-    pass
+    def f(self, a, b, /):
+        return a, b
 
-class X:
-    def f(self, *, __a=42):
-        return __a
-def test_mangling():
+class TestMangling(object):
     """
-    >>> X().f()
+    >>> TestMangling().f()
     42
+    >>> TestMangling().f2()
+    42
+    >>> TestMangling().f3()
+    (42, 43)
+    >>> TestMangling().f4()
+    (42, 43, 44)
+    >>> TestMangling().f2(1)
+    1
+    >>> TestMangling().f3(1, __b=2)
+    (1, 2)
+    >>> TestMangling().f4(1, __b=2, __c=3)
+    (1, 2, 3)
     """
-    pass
+    def f(self, *, __a=42):
+        return __a
+
+    def f2(self, __a=42, /):
+        return __a
 
-def global_pos_only_f(a, b, /):
-    pass
+    def f3(self, __a=42, /, __b=43):
+        return (__a, __b)
 
-def test_module_function():
+    def f4(self, __a=42, /, __b=43, *, __c=44):
+        return (__a, __b, __c)
+
+def test_module_function(a, b, /):
     """
-    >>> global_pos_only_f()
+    >>> test_module_function(1, 2)
+    >>> test_module_function()
     Traceback (most recent call last):
-    TypeError: global_pos_only_f() takes exactly 2 positional arguments (0 given)
+    TypeError: test_module_function() takes exactly 2 positional arguments (0 given)
     """
-    pass
 
 def test_closures1(x,y):
     """
@@ -321,3 +357,141 @@ def test_same_keyword_as_positional_with_kwargs(something, /, **kwargs):
     (42, {})
     """
     return (something, kwargs)
+
+def test_serialization1(a, b, /):
+    """
+    >>> pickled_posonly = pickle.dumps(test_serialization1)
+    >>> unpickled_posonly = pickle.loads(pickled_posonly)
+    >>> unpickled_posonly(1, 2)
+    (1, 2)
+    >>> unpickled_posonly(a=1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_serialization1() takes exactly 2 positional arguments (0 given)
+    """
+    return (a, b)
+
+def test_serialization2(a, /, b):
+    """
+    >>> pickled_optional = pickle.dumps(test_serialization2)
+    >>> unpickled_optional = pickle.loads(pickled_optional)
+    >>> unpickled_optional(1, 2)
+    (1, 2)
+    >>> unpickled_optional(a=1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_serialization2() takes exactly 2 positional arguments (0 given)
+    """
+    return (a, b)
+
+def test_serialization3(a=1, /, b=2):
+    """
+    >>> pickled_defaults = pickle.dumps(test_serialization3)
+    >>> unpickled_defaults = pickle.loads(pickled_defaults)
+    >>> unpickled_defaults(1, 2)
+    (1, 2)
+    >>> unpickled_defaults(a=1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_serialization3() got an unexpected keyword argument 'a'
+    """
+    return (a, b)
+
+async def test_async(a=1, /, b=2):
+    """
+    >>> test_async(a=1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_async() got an unexpected keyword argument 'a'
+    """
+    return a, b
+
+def test_async_call(*args, **kwargs):
+    """
+    >>> test_async_call(1, 2)
+    >>> test_async_call(1, b=2)
+    >>> test_async_call(1)
+    >>> test_async_call()
+    """
+    if sys.version_info < (3, 6):
+        return
+    try:
+        coro = test_async(*args, **kwargs)
+        coro.send(None)
+    except StopIteration as e:
+        result = e.value
+    assert result == (1, 2)
+
+
+def test_generator(a=1, /, b=2):
+    """
+    >>> test_generator(a=1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_generator() got an unexpected keyword argument 'a'
+    >>> gen = test_generator(1, 2)
+    >>> next(gen)
+    (1, 2)
+    >>> gen = test_generator(1, b=2)
+    >>> next(gen)
+    (1, 2)
+    >>> gen = test_generator(1)
+    >>> next(gen)
+    (1, 2)
+    >>> gen = test_generator()
+    >>> next(gen)
+    (1, 2)
+    """
+    yield a, b
+
+def f_call_1_0_0(a,/):
+    """
+    >>> f_call_1_0_0(1)
+    (1,)
+    """
+    return (a,)
+
+def f_call_1_1_0(a,/,b):
+    """
+    >>> f_call_1_1_0(1,2)
+    (1, 2)
+    """
+    return (a,b)
+
+def f_call_1_1_1(a,/,b,*,c):
+    """
+    >>> f_call_1_1_1(1,2,c=3)
+    (1, 2, 3)
+    """
+    return (a,b,c)
+
+def f_call_1_1_1_star(a,/,b,*args,c):
+    """
+    >>> f_call_1_1_1_star(1,2,c=3)
+    (1, 2, (), 3)
+    >>> f_call_1_1_1_star(1,2,3,4,5,6,7,8,c=9)
+    (1, 2, (3, 4, 5, 6, 7, 8), 9)
+    """
+    return (a,b,args,c)
+
+def f_call_1_1_1_kwds(a,/,b,*,c,**kwds):
+    """
+    >>> f_call_1_1_1_kwds(1,2,c=3)
+    (1, 2, 3, {})
+    >>> f_call_1_1_1_kwds(1,2,c=3,d=4,e=5) == (1, 2, 3, {'d': 4, 'e': 5})
+    True
+    """
+    return (a,b,c,kwds)
+
+def f_call_1_1_1_star_kwds(a,/,b,*args,c,**kwds):
+    """
+    >>> f_call_1_1_1_star_kwds(1,2,c=3,d=4,e=5) == (1, 2, (), 3, {'d': 4, 'e': 5})
+    True
+    >>> f_call_1_1_1_star_kwds(1,2,3,4,c=5,d=6,e=7) == (1, 2, (3, 4), 5, {'d': 6, 'e': 7})
+    True
+    """
+    return (a,b,args,c,kwds)
+
+def f_call_one_optional_kwd(a,/,*,b=2):
+    """
+    >>> f_call_one_optional_kwd(1)
+    (1, 2)
+    >>> f_call_one_optional_kwd(1, b=3)
+    (1, 3)
+    """
+    return (a,b)