Merge branch 'master' into python-2.4

test/simple_source/bug31/04_def_annotate.py

@@ -1,13 +1,42 @@
-# Python 3 annotations
+# Python 3 positional, kwonly, varargs, and annotations. Ick.
 
-def foo(a, b: 'annotating b', c: int) -> float:
-    print(a + b + c)
+# RUNNABLE!
+def test1(args_1, c: int, w=4, *varargs: int, **kwargs: 'annotating kwargs') -> tuple:
+    return (args_1, c, w, kwargs)
+
+def test2(args_1, args_2, c: int, w=4, *varargs: int, **kwargs: 'annotating kwargs'):
+    return (args_1, args_2, c, w, varargs, kwargs)
+
+def test3(c: int, w=4, *varargs: int, **kwargs: 'annotating kwargs') -> float:
+    return 5.4
+
+def test4(a: float, c: int, *varargs: int, **kwargs: 'annotating kwargs') -> float:
+    return 5.4
+
+def test5(a: float, c: int = 5, *varargs: int, **kwargs: 'annotating kwargs') -> float:
+    return 5.4
+
+def test6(a: float, c: int, test=None):
+    return (a, c, test)
+
+def test7(*varargs: int, **kwargs):
+    return (varargs, kwargs)
+
+def test8(x=55, *varargs: int, **kwargs) -> list:
+    return (x, varargs, kwargs)
+
+def test9(arg_1=55, *varargs: int, y=5, **kwargs):
+    return x, varargs, int, y, kwargs
+
+def test10(args_1, b: 'annotating b', c: int) -> float:
+    return 5.4
+
+class IOBase:
+    pass
 
 # Python 3.1 _pyio.py uses the  -> "IOBase" annotation
-def open(file, mode = "r", buffering = None,
-         encoding = None, errors = None,
-         newline = None, closefd = True) -> "IOBase":
-    return text
+def o(f, mode = "r", buffering = None) -> "IOBase":
+    return (f, mode, buffering)
 
 def foo1(x: 'an argument that defaults to 5' = 5):
     print(x)
@@ -18,13 +47,38 @@ def div(a: dict(type=float, help='the dividend'),
     """Divide a by b"""
     return a / b
 
-class TestSignatureObject(unittest.TestCase):
-    def test_signature_on_wkwonly(self):
-        def test(*, a:float, b:str) -> int:
-            pass
+# FIXME:
+# class TestSignatureObject():
+#     def test_signature_on_wkwonly(self):
+#         def test(*, a:float, b:str) -> int:
+#             pass
 
-class SupportsInt(_Protocol):
+class SupportsInt():
 
-    @abstractmethod
     def __int__(self) -> int:
         pass
+
+def ann1(args_1, b: 'annotating b', c: int, *varargs: str) -> float:
+    assert ann1.__annotations__['b'] == 'annotating b'
+    assert ann1.__annotations__['c'] == int
+    assert ann1.__annotations__['varargs'] == str
+    assert ann1.__annotations__['return'] == float
+
+def ann2(args_1, b: int = 5, **kwargs: float) -> float:
+    assert ann2.__annotations__['b'] == int
+    assert ann2.__annotations__['kwargs'] == float
+    assert ann2.__annotations__['return'] == float
+    assert b == 5
+
+
+assert test1(1, 5) == (1, 5, 4, {})
+assert test1(1, 5, 6, foo='bar') == (1, 5, 6, {'foo': 'bar'})
+assert test2(2, 3, 4) == (2, 3, 4, 4, (), {})
+assert test3(10, foo='bar') == 5.4
+assert test4(9.5, 7, 6, 4, bar='baz') == 5.4
+### FIXME: fill in...
+assert test6(1.2, 3) == (1.2, 3, None)
+assert test6(2.3, 4, 5) == (2.3, 4, 5)
+
+ann1(1, 'test', 5)
+ann2(1)

uncompyle6/parsers/parse3.py

@@ -26,6 +26,7 @@ If we succeed in creating a parse tree, then we have a Python program
 that a later phase can turn into a sequence of ASCII text.
 """
 
+import re
 from uncompyle6.scanners.tok import Token
 from uncompyle6.parser import PythonParser, PythonParserSingle, nop_func
 from uncompyle6.parsers.treenode import SyntaxTree
@@ -1051,7 +1052,7 @@ class Python3Parser(PythonParser):
                             (kwargs, 'pos_arg ' * args_pos, opname))
                 self.add_unique_rule(rule, opname, token.attr, customize)
 
-                if opname.startswith('MAKE_FUNCTION_A'):
+                if re.search('^MAKE_FUNCTION.*_A', opname):
                     if self.version >= 3.6:
                         rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST LOAD_CONST %s' %
                                 (('pos_arg ' * (args_pos)),
@@ -1064,21 +1065,27 @@ class Python3Parser(PythonParser):
                         # Normally we remove EXTENDED_ARG from the opcodes, but in the case of
                         # annotated functions can use the EXTENDED_ARG tuple to signal we have an annotated function.
                         # Yes this is a little hacky
-                        rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %
-                                (('pos_arg ' * (args_pos)),
+                        if self.version < 3.5:
+                            # 3.3 and 3.4 put kwargs before pos_arg
+                            pos_kw_tuple = (('kwargs ' * args_kw), ('pos_arg ' * (args_pos)))
+                        else:
+                            # 3.5 puts pos_arg before kwargs
+                            pos_kw_tuple = (('pos_arg ' * (args_pos), ('kwargs ' * args_kw)))
+                        rule = ('mkfunc_annotate ::= %s%s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %
+                                ( pos_kw_tuple[0], pos_kw_tuple[1],
                                  ('call ' * (annotate_args-1)), opname))
                         self.add_unique_rule(rule, opname, token.attr, customize)
-                        rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %
-                                (('pos_arg ' * (args_pos)),
+                        rule = ('mkfunc_annotate ::= %s%s%sannotate_tuple LOAD_CONST LOAD_CONST EXTENDED_ARG %s' %
+                                ( pos_kw_tuple[0], pos_kw_tuple[1],
                                  ('annotate_arg ' * (annotate_args-1)), opname))
                     else:
                         # See above comment about use of EXTENDED_ARG
-                        rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %
-                                (('pos_arg ' * (args_pos)),
+                        rule = ('mkfunc_annotate ::= %s%s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %
+                                (('pos_arg ' * (args_pos)),  ('kwargs ' * args_kw),
                                  ('annotate_arg ' * (annotate_args-1)), opname))
                         self.add_unique_rule(rule, opname, token.attr, customize)
-                        rule = ('mkfunc_annotate ::= %s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %
-                                (('pos_arg ' * (args_pos)),
+                        rule = ('mkfunc_annotate ::= %s%s%sannotate_tuple LOAD_CONST EXTENDED_ARG %s' %
+                                (('pos_arg ' * (args_pos)),  ('kwargs ' * args_kw),
                                  ('call ' * (annotate_args-1)), opname))
                     self.addRule(rule, nop_func)
             elif opname == 'RETURN_VALUE_LAMBDA':

uncompyle6/scanners/scanner3.py

@@ -339,9 +339,10 @@ class Scanner3(Scanner):
                     attr = attr[:4] # remove last value: attr[5] == False
                 else:
                     pos_args, name_pair_args, annotate_args = parse_fn_counts(inst.argval)
-                    pattr = ("%d positional, %d keyword pair, %d annotated" %
+                    pattr = ("%d positional, %d keyword only, %d annotated" %
                                  (pos_args, name_pair_args, annotate_args))
                     if name_pair_args > 0:
+                        # FIXME: this should probably be K_
                         opname = '%s_N%d' % (opname, name_pair_args)
                         pass
                     if annotate_args > 0:

uncompyle6/semantics/make_function.py

@@ -129,10 +129,6 @@ def make_function3_annotate(self, node, is_lambda, nested=1,
     indent = ' ' * l
     line_number = self.line_number
 
-    if code_has_star_arg(code):
-        self.write('*%s' % code.co_varnames[argc + kw_pairs])
-        argc += 1
-
     i = len(paramnames) - len(defparams)
     suffix = ''
 
@@ -142,7 +138,11 @@ def make_function3_annotate(self, node, is_lambda, nested=1,
         self.write(suffix, param)
         suffix = ', '
         if param in annotate_tuple[0].attr:
-            p = [x for x in annotate_tuple[0].attr].index(param)
+            # p = [x for x in annotate_tuple[0].attr].index(param)
+            l = []
+            for x in annotate_tuple[0].attr:
+                l.append(x)
+            p = l.index(param)
             self.write(': ')
             self.preorder(node[p])
             if (line_number != self.line_number):
@@ -183,7 +183,17 @@ def make_function3_annotate(self, node, is_lambda, nested=1,
                 suffix = ', '
 
 
+    if code_has_star_arg(code):
+        star_arg = code.co_varnames[argc + kw_pairs]
+        self.write(suffix, '*%s' % star_arg)
+        if star_arg in annotate_tuple[0].attr:
+            p = annotate_tuple[0].attr.index(star_arg) + pos_args + kw_args
+            self.write(': ')
+            self.preorder(node[p])
+        argc += 1
+
     # self.println(indent, '#flags:\t', int(code.co_flags))
+    ends_in_comma = False
     if kw_args + annotate_argc > 0:
         if no_paramnames:
             if not code_has_star_arg(code):
@@ -194,49 +204,47 @@ def make_function3_annotate(self, node, is_lambda, nested=1,
                 pass
             else:
                 self.write(", ")
+            ends_in_comma = True
 
-            kwargs = node[0]
-            last = len(kwargs)-1
-            i = 0
-            for n in node[0]:
-                if n == 'kwarg':
-                    if (line_number != self.line_number):
-                        self.write("\n" + indent)
-                        line_number = self.line_number
-                    self.write('%s=' % n[0].pattr)
-                    self.preorder(n[1])
-                    if i < last:
-                        self.write(', ')
-                    i += 1
-                    pass
-                pass
-            annotate_args = []
-            for n in node:
-                if n == 'annotate_arg':
-                    annotate_args.append(n[0])
-                elif n == 'annotate_tuple':
-                    t = n[0].attr
-                    if t[-1] == 'return':
-                        t = t[0:-1]
-                        annotate_args = annotate_args[:-1]
-                        pass
-                    last = len(annotate_args) - 1
-                    for i in range(len(annotate_args)):
-                        self.write("%s: " % (t[i]))
-                        self.preorder(annotate_args[i])
-                        if i < last:
-                            self.write(', ')
-                            pass
-                        pass
-                    break
+        kwargs = node[1]
+        last = len(kwargs)-1
+        i = 0
+        for n in node[1]:
+            if n == 'kwarg':
+                if argc > 0 and not ends_in_comma:
+                    self.write(', ')
+                if (line_number != self.line_number):
+                    self.write("\n" + indent)
+                    line_number = self.line_number
+                kn = n[0].pattr
+                if kn in annotate_tuple[0].attr:
+                    p = annotate_tuple[0].attr.index(star_arg) + pos_args + kw_args
+                    self.write('%s: ' % kn)
+                    self.preorder(node[p])
+                    self.write('=')
+                else:
+                    self.write('%s=' % kn)
+                self.preorder(n[1])
+                if i < last:
+                    self.write(', ')
+                    ends_in_comma = True
+                else:
+                    ends_in_comma = False
+                i += 1
                 pass
             pass
+        pass
 
 
         if code_has_star_star_arg(code):
-            if argc > 0:
+            if argc > 0 and not ends_in_comma:
                 self.write(', ')
-            self.write('**%s' % code.co_varnames[argc + kw_pairs])
+            star_star_arg = code.co_varnames[argc + kw_pairs]
+            self.write('**%s' % star_star_arg)
+            if star_star_arg in annotate_tuple[0].attr:
+                p = annotate_tuple[0].attr.index(star_star_arg) + pos_args + kw_args
+                self.write(': ')
+                self.preorder(node[p])
 
     if is_lambda:
         self.write(": ")
@@ -473,7 +481,7 @@ def make_function3(self, node, is_lambda, nested=1, code_node=None):
 
     # Thank you, Python.
 
-    def build_param(ast, name, default):
+    def build_param(ast, name, default, annotation=None):
         """build parameters:
             - handle defaults
             - handle format tuple parameters
@@ -483,7 +491,10 @@ def make_function3(self, node, is_lambda, nested=1, code_node=None):
         else:
             value = self.traverse(default, indent='')
         maybe_show_tree_param_default(self.showast, name, value)
-        result = '%s=%s' % (name,  value)
+        if annotation:
+            result = '%s: %s=%s' % (name, annotation, value)
+        else:
+            result = '%s=%s' % (name, value)
 
         # The below can probably be removed. This is probably
         # a holdover from days when LOAD_CONST erroneously
@@ -685,17 +696,30 @@ def make_function3(self, node, is_lambda, nested=1, code_node=None):
     params = []
     if defparams:
         for i, defparam in enumerate(defparams):
-            params.append(build_param(ast, paramnames[i], defparam))
+            params.append(build_param(ast, paramnames[i], defparam,
+                                      annotate_dict.get(paramnames[i])))
 
-        params += paramnames[i+1:]
+        for param in paramnames[i+1:]:
+            if param in annotate_dict:
+                params.append("%s: %s" % (param, annotate_dict[param]))
+            else:
+                params.append(param)
     else:
-        params = paramnames
+        for param in paramnames:
+            if param in annotate_dict:
+                params.append("%s: %s" % (param, annotate_dict[param]))
+            else:
+                params.append(param)
 
     params.reverse() # back to correct order
 
     if code_has_star_arg(code):
         if self.version > 3.0:
-            params.append('*%s' % code.co_varnames[argc + kw_pairs])
+            star_arg = code.co_varnames[argc + kw_pairs]
+            if star_arg in annotate_dict:
+                params.append('*%s: %s' %(star_arg, annotate_dict[star_arg]))
+            else:
+                params.append('*%s' % star_arg)
         else:
             params.append('*%s' % code.co_varnames[argc])
         argc += 1
@@ -720,7 +744,6 @@ def make_function3(self, node, is_lambda, nested=1, code_node=None):
             ast[-1] = ast_expr
             pass
     else:
-        # FIXME: add annotations here
         self.write("(", ", ".join(params))
     # self.println(indent, '#flags:\t', int(code.co_flags))
 
@@ -814,7 +837,11 @@ def make_function3(self, node, is_lambda, nested=1, code_node=None):
     if code_has_star_star_arg(code):
         if argc > 0 and not ends_in_comma:
             self.write(', ')
-        self.write('**%s' % code.co_varnames[argc + kw_pairs])
+        star_star_arg = code.co_varnames[argc + kw_pairs]
+        if annotate_dict and star_star_arg and star_star_arg in annotate_dict:
+            self.write('**%s: %s' %(star_star_arg, annotate_dict[star_star_arg]))
+        else:
+            self.write('**%s' % star_star_arg)
 
     if is_lambda:
         self.write(": ")

uncompyle6/semantics/pysource.py

@@ -1436,9 +1436,7 @@ class SourceWalker(GenericASTTraversal, object):
         n = len(node) - 1
         if node.kind != 'expr':
             if node == 'kwarg':
-                self.write('(')
-                self.template_engine(('%[0]{pattr}=%c', 1), node)
-                self.write(')')
+                self.template_engine(('(%[0]{pattr}=%c)', 1), node)
                 return
 
             kwargs = None