Merge pull request #2927 from rjtobin/pos_args

Adds positional only args support (PEP 570)

Cython/Compiler/Nodes.py

@@ -859,8 +859,9 @@ class CArgDeclNode(Node):
     # annotation     ExprNode or None   Py3 function arg annotation
     # is_self_arg    boolean            Is the "self" arg of an extension type method
     # is_type_arg    boolean            Is the "class" arg of an extension type classmethod
-    # is_kw_only     boolean            Is a keyword-only argument
+    # kw_only        boolean            Is a keyword-only argument
     # is_dynamic     boolean            Non-literal arg stored inside CyFunction
+    # pos_only       boolean            Is a positional-only argument
 
     child_attrs = ["base_type", "declarator", "default", "annotation"]
     outer_attrs = ["default", "annotation"]
@@ -869,6 +870,7 @@ class CArgDeclNode(Node):
     is_type_arg = 0
     is_generic = 1
     kw_only = 0
+    pos_only = 0
     not_none = 0
     or_none = 0
     type = None
@@ -3653,6 +3655,7 @@ class DefNodeWrapper(FuncDefNode):
         positional_args = []
         required_kw_only_args = []
         optional_kw_only_args = []
+        num_pos_only_args = 0
         for arg in args:
             if arg.is_generic:
                 if arg.default:
@@ -3666,6 +3669,9 @@ class DefNodeWrapper(FuncDefNode):
                 elif not arg.is_self_arg and not arg.is_type_arg:
                     positional_args.append(arg)
 
+                if arg.pos_only:
+                    num_pos_only_args += 1
+
         # sort required kw-only args before optional ones to avoid special
         # cases in the unpacking code
         kw_only_args = required_kw_only_args + optional_kw_only_args
@@ -3683,10 +3689,10 @@ class DefNodeWrapper(FuncDefNode):
 
         code.putln('{')
         all_args = tuple(positional_args) + tuple(kw_only_args)
-        code.putln("static PyObject **%s[] = {%s,0};" % (
+        code.putln("static PyObject **%s[] = {%s};" % (
             Naming.pykwdlist_cname,
             ','.join(['&%s' % code.intern_identifier(arg.name)
-                      for arg in all_args])))
+                      for arg in all_args if not arg.pos_only] + ['0'])))
 
         # Before being converted and assigned to the target variables,
         # borrowed references to all unpacked argument values are
@@ -3704,8 +3710,8 @@ class DefNodeWrapper(FuncDefNode):
             Naming.kwds_cname))
         self.generate_keyword_unpacking_code(
             min_positional_args, max_positional_args,
-            has_fixed_positional_count, has_kw_only_args,
-            all_args, argtuple_error_label, code)
+            num_pos_only_args, has_fixed_positional_count,
+            has_kw_only_args, all_args, argtuple_error_label, code)
 
         # --- optimised code when we do not receive any keyword arguments
         if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
@@ -3868,8 +3874,8 @@ class DefNodeWrapper(FuncDefNode):
                 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
 
     def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
-                                        has_fixed_positional_count, has_kw_only_args,
-                                        all_args, argtuple_error_label, code):
+                                        num_pos_only_args, has_fixed_positional_count,
+                                        has_kw_only_args, all_args, argtuple_error_label, code):
         code.putln('Py_ssize_t kw_args;')
         code.putln('const Py_ssize_t pos_args = PyTuple_GET_SIZE(%s);' % Naming.args_cname)
         # copy the values from the args tuple and check that it's not too long
@@ -3899,9 +3905,12 @@ class DefNodeWrapper(FuncDefNode):
         code.putln('kw_args = PyDict_Size(%s);' % Naming.kwds_cname)
         if self.num_required_args or max_positional_args > 0:
             last_required_arg = -1
+            last_required_posonly_arg = -1
             for i, arg in enumerate(all_args):
                 if not arg.default:
                     last_required_arg = i
+                if arg.pos_only and not arg.default:
+                    last_required_posonly_arg = i
             if last_required_arg < max_positional_args:
                 last_required_arg = max_positional_args-1
             if max_positional_args > 0:
@@ -3915,6 +3924,12 @@ class DefNodeWrapper(FuncDefNode):
                     else:
                         code.putln('case %2d:' % i)
                 pystring_cname = code.intern_identifier(arg.name)
+                if arg.pos_only:
+                    if i == last_required_posonly_arg:
+                        code.put_goto(argtuple_error_label)
+                    elif i == last_required_arg:
+                        code.putln('break;')
+                    continue
                 if arg.default:
                     if arg.kw_only:
                         # optional kw-only args are handled separately below
@@ -3969,20 +3984,45 @@ class DefNodeWrapper(FuncDefNode):
         # arguments, this will always do the right thing for unpacking
         # keyword arguments, so that we can concentrate on optimising
         # common cases above.
+        #
+        # ParseOptionalKeywords() needs to know how many of the arguments
+        # that could be passed as keywords have in fact been passed as
+        # positional args.
+        if num_pos_only_args > 0:
+            # There are positional-only arguments which we don't want to count,
+            # since they cannot be keyword arguments.  Subtract the number of
+            # pos-only arguments from the number of positional arguments we got.
+            # If we get a negative number then none of the keyword arguments were
+            # passed as positional args.
+            code.putln('const Py_ssize_t kwd_pos_args = (pos_args < %d) ? 0 : (pos_args - %d);' % (
+                num_pos_only_args, num_pos_only_args))
+        elif max_positional_args > 0:
+            code.putln('const Py_ssize_t kwd_pos_args = pos_args;')
+
         if max_positional_args == 0:
             pos_arg_count = "0"
         elif self.star_arg:
-            code.putln("const Py_ssize_t used_pos_args = (pos_args < %d) ? pos_args : %d;" % (
-                max_positional_args, max_positional_args))
+            # If there is a *arg, the number of used positional args could be larger than
+            # the number of possible keyword arguments.  But ParseOptionalKeywords() uses the
+            # number of positional args as an index into the keyword argument name array,
+            # if this is larger than the number of kwd args we get a segfault.  So round
+            # this down to max_positional_args - num_pos_only_args (= num possible kwd args).
+            code.putln("const Py_ssize_t used_pos_args = (kwd_pos_args < %d) ? kwd_pos_args : %d;" % (
+                max_positional_args - num_pos_only_args, max_positional_args - num_pos_only_args))
             pos_arg_count = "used_pos_args"
         else:
-            pos_arg_count = "pos_args"
+            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)))
@@ -3991,12 +4031,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
@@ -4012,8 +4059,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('}')

Cython/Compiler/Parsing.py

@@ -2965,7 +2965,7 @@ def p_exception_value_clause(s):
             exc_val = p_test(s)
     return exc_val, exc_check
 
-c_arg_list_terminators = cython.declare(set, set(['*', '**', '.', ')', ':']))
+c_arg_list_terminators = cython.declare(set, set(['*', '**', '.', ')', ':', '/']))
 
 def p_c_arg_list(s, ctx = Ctx(), in_pyfunc = 0, cmethod_flag = 0,
                  nonempty_declarators = 0, kw_only = 0, annotated = 1):
@@ -3424,6 +3424,20 @@ def p_varargslist(s, terminator=')', annotated=1):
                         annotated = annotated)
     star_arg = None
     starstar_arg = None
+    if s.sy == '/':
+        if len(args) == 0:
+            s.error("Got zero positional-only arguments despite presence of "
+                    "positional-only specifier '/'")
+        s.next()
+        # Mark all args to the left as pos only
+        for arg in args:
+            arg.pos_only = 1
+        if s.sy == ',':
+            s.next()
+            args.extend(p_c_arg_list(s, in_pyfunc = 1,
+                nonempty_declarators = 1, annotated = annotated))
+        elif s.sy != terminator:
+            s.error("Syntax error in Python function argument list")
     if s.sy == '*':
         s.next()
         if s.sy == 'IDENT':

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

+# mode: run
+# tag: posonly
+
+# TODO: remove posonly tag before merge
+
+import cython
+import sys
+import pickle
+
+def test_optional_posonly_args1(a, b=10, /, c=100):
+    """
+    >>> test_optional_posonly_args1(1, 2, 3)
+    6
+    >>> test_optional_posonly_args1(1, 2, c=3)
+    6
+    >>> test_optional_posonly_args1(1, b=2, c=3)
+    Traceback (most recent call last):
+    TypeError: test_optional_posonly_args1() got an unexpected keyword argument 'b'
+    >>> test_optional_posonly_args1(1, 2)
+    103
+    >>> test_optional_posonly_args1(1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_optional_posonly_args1() got an unexpected keyword argument 'b'
+    """
+    return a + b + c
+
+def test_optional_posonly_args2(a=1, b=10, /, c=100):
+    """
+    >>> test_optional_posonly_args2(1, 2, 3)
+    6
+    >>> test_optional_posonly_args2(1, 2, c=3)
+    6
+    >>> test_optional_posonly_args2(1, b=2, c=3)
+    Traceback (most recent call last):
+    TypeError: test_optional_posonly_args2() got an unexpected keyword argument 'b'
+    >>> test_optional_posonly_args2(1, 2)
+    103
+    >>> test_optional_posonly_args2(1, b=2)
+    Traceback (most recent call last):
+    TypeError: test_optional_posonly_args2() got an unexpected keyword argument 'b'
+    >>> test_optional_posonly_args2(1, c=2)
+    13
+    """
+    return a + b + c
+
+# 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: 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, /):
+    """
+    >>> test_pos_only_call_via_unpacking(*[1,2])
+    3
+    """
+    return 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
+    """
+
+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)
+    """
+
+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)
+    """
+
+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)
+    >>> test_positional_only_and_arg_invalid_calls(1)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_arg_invalid_calls() takes exactly 3 positional arguments (1 given)
+    >>> test_positional_only_and_arg_invalid_calls(1,2,3,4)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_arg_invalid_calls() takes exactly 3 positional arguments (4 given)
+    """
+
+def test_positional_only_and_optional_arg_invalid_calls(a, b, /, c=3):
+    """
+    >>> test_positional_only_and_optional_arg_invalid_calls(1, 2)
+    >>> test_positional_only_and_optional_arg_invalid_calls(1)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_optional_arg_invalid_calls() takes at least 2 positional arguments (1 given)
+    >>> test_positional_only_and_optional_arg_invalid_calls()
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_optional_arg_invalid_calls() takes at least 2 positional arguments (0 given)
+    >>> test_positional_only_and_optional_arg_invalid_calls(1, 2, 3, 4)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_and_optional_arg_invalid_calls() takes at most 3 positional arguments (4 given)
+    """
+
+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, /):
+    """
+    >>> test_positional_only_invalid_calls(1, 2)
+    >>> test_positional_only_invalid_calls(1)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_invalid_calls() takes exactly 2 positional arguments (1 given)
+    >>> test_positional_only_invalid_calls()
+    Traceback (most recent call last):
+    TypeError: test_positional_only_invalid_calls() takes exactly 2 positional arguments (0 given)
+    >>> test_positional_only_invalid_calls(1, 2, 3)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_invalid_calls() takes exactly 2 positional arguments (3 given)
+    """
+
+def test_positional_only_with_optional_invalid_calls(a, b=2, /):
+    """
+    >>> test_positional_only_with_optional_invalid_calls(1)
+    >>> test_positional_only_with_optional_invalid_calls()
+    Traceback (most recent call last):
+    TypeError: test_positional_only_with_optional_invalid_calls() takes at least 1 positional argument (0 given)
+    >>> test_positional_only_with_optional_invalid_calls(1, 2, 3)
+    Traceback (most recent call last):
+    TypeError: test_positional_only_with_optional_invalid_calls() takes at most 2 positional arguments (3 given)
+    """
+
+def test_no_standard_args_usage(a, b, /, *, c):
+    """
+    >>> test_no_standard_args_usage(1, 2, c=3)
+    >>> test_no_standard_args_usage(1, b=2, c=3)
+    Traceback (most recent call last):
+    TypeError: test_no_standard_args_usage() takes exactly 2 positional arguments (1 given)
+    """
+
+#def test_change_default_pos_only():
+# TODO: probably remove this, since  __defaults__ is not writable in Cython?
+#    """
+#    >>> test_change_default_pos_only()
+#    True
+#    True
+#    """
+#    def f(a, b=2, /, c=3):
+#        return a + b + c
+#
+#    print((2,3) == f.__defaults__)
+#    f.__defaults__ = (1, 2, 3)
+#    print(f(1, 2, 3) == 6)
+
+def test_lambdas():
+    """
+    >>> test_lambdas()
+    3
+    3
+    3
+    3
+    3
+    """
+    x = lambda a, /, b: a + b
+    print(x(1,2))
+    print(x(1,b=2))
+
+    x = lambda a, /, b=2: a + b
+    print(x(1))
+
+    x = lambda a, b, /: a + b
+    print(x(1, 2))
+
+    x = lambda a, b, /, : a + b
+    print(x(1, 2))
+
+class TestPosonlyMethods(object):
+    """
+    >>> TestPosonlyMethods().f(1,2)
+    (1, 2)
+    >>> TestPosonlyMethods.f(TestPosonlyMethods(), 1, 2)
+    (1, 2)
+    >>> try:
+    ...     TestPosonlyMethods.f(1,2)
+    ... except TypeError:
+    ...    print("Got type error")
+    Got type error
+    >>> TestPosonlyMethods().f(1, b=2)
+    Traceback (most recent call last):
+    TypeError: f() takes exactly 3 positional arguments (2 given)
+    """
+    def f(self, a, b, /):
+        return a, b
+
+class TestMangling(object):
+    """
+    >>> 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)
+    """
+    def f(self, *, __a=42):
+        return __a
+
+    def f2(self, __a=42, /):
+        return __a
+
+    def f3(self, __a=42, /, __b=43):
+        return (__a, __b)
+
+    def f4(self, __a=42, /, __b=43, *, __c=44):
+        return (__a, __b, __c)
+
+def test_module_function(a, b, /):
+    """
+    >>> test_module_function(1, 2)
+    >>> test_module_function()
+    Traceback (most recent call last):
+    TypeError: test_module_function() takes exactly 2 positional arguments (0 given)
+    """
+
+def test_closures1(x,y):
+    """
+    >>> test_closures1(1,2)(3,4)
+    10
+    >>> test_closures1(1,2)(3)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 2 positional arguments (1 given)
+    >>> test_closures1(1,2)(3,4,5)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 2 positional arguments (3 given)
+    """
+    def g(x2,/,y2):
+        return x + y + x2 + y2
+    return g
+
+def test_closures2(x,/,y):
+    """
+    >>> test_closures2(1,2)(3,4)
+    10
+    """
+    def g(x2,y2):
+        return x + y + x2 + y2
+    return g
+
+def test_closures3(x,/,y):
+    """
+    >>> test_closures3(1,2)(3,4)
+    10
+    >>> test_closures3(1,2)(3)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 2 positional arguments (1 given)
+    >>> test_closures3(1,2)(3,4,5)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 2 positional arguments (3 given)
+    """
+    def g(x2,/,y2):
+        return x + y + x2 + y2
+    return g
+
+def test_same_keyword_as_positional_with_kwargs(something, /, **kwargs):
+    """
+    >>> test_same_keyword_as_positional_with_kwargs(42, something=42)
+    (42, {'something': 42})
+    >>> test_same_keyword_as_positional_with_kwargs(something=42)
+    Traceback (most recent call last):
+    TypeError: test_same_keyword_as_positional_with_kwargs() takes exactly 1 positional argument (0 given)
+    >>> test_same_keyword_as_positional_with_kwargs(42)
+    (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)