Rewrite the arglist rule to actually match the Python grammar.

whitequark · whitequark · commit cd2f7ac6a165 · 2017-02-08T10:59:52.000Z
Fixes #5.
diff --git a/pythonparser/parser.py b/pythonparser/parser.py
@@ -1805,13 +1805,9 @@ def classdef__30(self, class_loc, name_tok, arglist_opt, colon_loc, body):
                             name_loc=name_tok.loc, colon_loc=colon_loc,
                             loc=class_loc.join(body[-1].loc))
 
-    @action(Rule("argument"))
-    def arglist_1(self, arg):
-        return [arg], self._empty_arglist()
-
     @action(Seq(Loc("*"), Rule("test"), Star(SeqN(1, Tok(","), Rule("argument"))),
                 Opt(Seq(Tok(","), Loc("**"), Rule("test")))))
-    def arglist_2(self, star_loc, stararg, postargs, kwarg_opt):
+    def arglist_1(self, star_loc, stararg, postargs, kwarg_opt):
         dstar_loc = kwarg = None
         if kwarg_opt:
             _, dstar_loc, kwarg = kwarg_opt
@@ -1828,31 +1824,32 @@ def arglist_2(self, star_loc, stararg, postargs, kwarg_opt):
                         star_loc=star_loc, dstar_loc=dstar_loc, loc=None)
 
     @action(Seq(Loc("**"), Rule("test")))
-    def arglist_3(self, dstar_loc, kwarg):
+    def arglist_2(self, dstar_loc, kwarg):
         return [], \
                ast.Call(args=[], keywords=[], starargs=None, kwargs=kwarg,
                         star_loc=None, dstar_loc=dstar_loc, loc=None)
 
-    @action(SeqN(0, Rule("argument"), Tok(",")))
-    def arglist_4(self, arg):
-        return [], ([arg], self._empty_arglist())
-
-    @action(Alt(Seq(Star(SeqN(0, Rule("argument"), Tok(","))),
-                    Alt(arglist_1, arglist_2, arglist_3)),
-                arglist_4))
-    def arglist(self, pre_args, rest):
-        # Python's grammar is very awkwardly formulated here in a way
-        # that is not easily amenable to our combinator approach.
-        # Thus it is changed to the equivalent:
-        #
-        #     arglist: (argument ',')* ( argument | ... ) | argument ','
-        #
+    @action(Seq(Rule("argument"),
+                Alt(SeqN(1, Tok(","), Alt(Rule("arglist_1"),
+                                          Rule("arglist_2"),
+                                          Rule("arglist_3"),
+                                          Eps())),
+                    Eps())))
+    def arglist_3(self, arg, cont):
+        if cont is None:
+            return [arg], self._empty_arglist()
+        else:
+            args, rest = cont
+            return [arg] + args, rest
+
+    @action(Alt(Rule("arglist_1"),
+                Rule("arglist_2"),
+                Rule("arglist_3")))
+    def arglist(self, args, call):
         """arglist: (argument ',')* (argument [','] |
                                      '*' test (',' argument)* [',' '**' test] |
                                      '**' test)"""
-        post_args, call = rest
-
-        for arg in pre_args + post_args:
+        for arg in args:
             if isinstance(arg, ast.keyword):
                 call.keywords.append(arg)
             elif len(call.keywords) > 0:
diff --git a/pythonparser/test/test_parser.py b/pythonparser/test/test_parser.py
@@ -835,6 +835,16 @@ def test_call(self):
             "  ^^ dstar_loc"
             "~~~~~~ loc")
 
+        self.assertParsesExpr(
+            {"ty": "Call", "func": self.ast_x, "starargs": None, "kwargs": self.ast_z,
+             "args": [self.ast_1], "keywords": []},
+            "x(1, **z)")
+
+        self.assertParsesExpr(
+            {"ty": "Call", "func": self.ast_x, "starargs": None, "kwargs": None,
+             "args": [self.ast_1, self.ast_2], "keywords": []},
+            "x(1, 2,)")
+
         self.assertParsesExpr(
             {"ty": "Call", "func": self.ast_x, "starargs": None, "kwargs": None,
              "keywords": [], "args": [
