Add Daira Hopwood's python-modernize patch to avoid introducing redundant parentheses in print() calls

edschofield · edschofield · commit aa7f991697d8 · 2014-08-07T13:45:18.000+10:00
Commit from github.com/python-modernize/python-modernize.git: d9e671c374a5dd12779027fd60aff690027d0d41

Also re-enable some lib2to3 tests
diff --git a/docs/futurize.rst b/docs/futurize.rst
@@ -187,6 +187,9 @@ The ``fix_print_with_import`` fixer in ``libfuturize.fixes`` changes the code to
 use print as a function and also adds ``from __future__ import
 print_function`` to the top of modules using ``print()``.
 
+In addition, it avoids adding an extra set of parentheses if these already
+exist. So ``print(x)`` does not become ``print((x))``.
+
 .. code-block:: python
 
     lib2to3.fixes.fix_raise
diff --git a/docs/whatsnew.rst b/docs/whatsnew.rst
@@ -12,9 +12,12 @@ What's new in version 0.12.5
 - Stage 1 of ``futurize`` no longer renames ``next`` methods to ``__next__``
   (issue #81). It still converts ``obj.next()`` method calls to
   ``next(obj)`` correctly.
-- Add :ref:`compatible-idioms` from Ed Schofield's PyConAU 2014 talk.
-- Add ``int.to_bytes()`` and ``int.from_bytes()`` (issue #85)
-- Add ``future.utils.raise_from`` as an equivalent to Py3's ``raise ... from ...`` syntax (issue #86).
+- Docs: Add :ref:`compatible-idioms` from Ed Schofield's PyConAU 2014 talk.
+- Add ``newint.to_bytes()`` and ``newint.from_bytes()`` (issue #85)
+- Add ``future.utils.raise_from`` as an equivalent to Py3's ``raise ... from
+  ...`` syntax (issue #86).
+- Prevent introduction of a second set of parentheses in ``print()`` calls in
+  some further cases.
 
 
 .. whats-new-0.12.4:
diff --git a/future/tests/test_libfuturize_fixers.py b/future/tests/test_libfuturize_fixers.py
@@ -231,113 +231,113 @@ def assert_runs_after(self, *names):
 # 
 #         s = "reduce()"
 #         self.unchanged(s)
-# 
-# class Test_print(FixerTestCase):
-#     fixer = "print"
-# 
-#     def test_prefix_preservation(self):
-#         b = """print 1,   1+1,   1+1+1"""
-#         a = """print(1,   1+1,   1+1+1)"""
-#         self.check(b, a)
-# 
-#     def test_idempotency(self):
-#         s = """print()"""
-#         self.unchanged(s)
-# 
-#         s = """print('')"""
-#         self.unchanged(s)
-# 
-#     def test_idempotency_print_as_function(self):
-#         self.refactor.driver.grammar = pygram.python_grammar_no_print_statement
-#         s = """print(1, 1+1, 1+1+1)"""
-#         self.unchanged(s)
-# 
-#         s = """print()"""
-#         self.unchanged(s)
-# 
-#         s = """print('')"""
-#         self.unchanged(s)
-# 
-#     def test_1(self):
-#         b = """print 1, 1+1, 1+1+1"""
-#         a = """print(1, 1+1, 1+1+1)"""
-#         self.check(b, a)
-# 
-#     def test_2(self):
-#         b = """print 1, 2"""
-#         a = """print(1, 2)"""
-#         self.check(b, a)
-# 
-#     def test_3(self):
-#         b = """print"""
-#         a = """print()"""
-#         self.check(b, a)
-# 
-#     def test_4(self):
-#         # from bug 3000
-#         b = """print whatever; print"""
-#         a = """print(whatever); print()"""
-#         self.check(b, a)
-# 
-#     def test_5(self):
-#         b = """print; print whatever;"""
-#         a = """print(); print(whatever);"""
-#         self.check(b, a)
-# 
-#     def test_tuple(self):
-#         b = """print (a, b, c)"""
-#         a = """print((a, b, c))"""
-#         self.check(b, a)
-# 
-#     # trailing commas
-# 
-#     def test_trailing_comma_1(self):
-#         b = """print 1, 2, 3,"""
-#         a = """print(1, 2, 3, end=' ')"""
-#         self.check(b, a)
-# 
-#     def test_trailing_comma_2(self):
-#         b = """print 1, 2,"""
-#         a = """print(1, 2, end=' ')"""
-#         self.check(b, a)
-# 
-#     def test_trailing_comma_3(self):
-#         b = """print 1,"""
-#         a = """print(1, end=' ')"""
-#         self.check(b, a)
-# 
-#     # >> stuff
-# 
-#     def test_vargs_without_trailing_comma(self):
-#         b = """print >>sys.stderr, 1, 2, 3"""
-#         a = """print(1, 2, 3, file=sys.stderr)"""
-#         self.check(b, a)
-# 
-#     def test_with_trailing_comma(self):
-#         b = """print >>sys.stderr, 1, 2,"""
-#         a = """print(1, 2, end=' ', file=sys.stderr)"""
-#         self.check(b, a)
-# 
-#     def test_no_trailing_comma(self):
-#         b = """print >>sys.stderr, 1+1"""
-#         a = """print(1+1, file=sys.stderr)"""
-#         self.check(b, a)
-# 
-#     def test_spaces_before_file(self):
-#         b = """print >>  sys.stderr"""
-#         a = """print(file=sys.stderr)"""
-#         self.check(b, a)
-# 
-#     def test_with_future_print_function(self):
-#         s = "from __future__ import print_function\n" \
-#             "print('Hai!', end=' ')"
-#         self.unchanged(s)
-# 
-#         b = "print 'Hello, world!'"
-#         a = "print('Hello, world!')"
-#         self.check(b, a)
-# 
-# 
+
+class Test_print(FixerTestCase):
+    fixer = "print"
+
+    def test_prefix_preservation(self):
+        b = """print 1,   1+1,   1+1+1"""
+        a = """print(1,   1+1,   1+1+1)"""
+        self.check(b, a)
+
+    def test_idempotency(self):
+        s = """print()"""
+        self.unchanged(s)
+
+        s = """print('')"""
+        self.unchanged(s)
+
+    def test_idempotency_print_as_function(self):
+        self.refactor.driver.grammar = pygram.python_grammar_no_print_statement
+        s = """print(1, 1+1, 1+1+1)"""
+        self.unchanged(s)
+
+        s = """print()"""
+        self.unchanged(s)
+
+        s = """print('')"""
+        self.unchanged(s)
+
+    def test_1(self):
+        b = """print 1, 1+1, 1+1+1"""
+        a = """print(1, 1+1, 1+1+1)"""
+        self.check(b, a)
+
+    def test_2(self):
+        b = """print 1, 2"""
+        a = """print(1, 2)"""
+        self.check(b, a)
+
+    def test_3(self):
+        b = """print"""
+        a = """print()"""
+        self.check(b, a)
+
+    def test_4(self):
+        # from bug 3000
+        b = """print whatever; print"""
+        a = """print(whatever); print()"""
+        self.check(b, a)
+
+    def test_5(self):
+        b = """print; print whatever;"""
+        a = """print(); print(whatever);"""
+        self.check(b, a)
+
+    def test_tuple(self):
+        b = """print (a, b, c)"""
+        a = """print((a, b, c))"""
+        self.check(b, a)
+
+    # trailing commas
+
+    def test_trailing_comma_1(self):
+        b = """print 1, 2, 3,"""
+        a = """print(1, 2, 3, end=' ')"""
+        self.check(b, a)
+
+    def test_trailing_comma_2(self):
+        b = """print 1, 2,"""
+        a = """print(1, 2, end=' ')"""
+        self.check(b, a)
+
+    def test_trailing_comma_3(self):
+        b = """print 1,"""
+        a = """print(1, end=' ')"""
+        self.check(b, a)
+
+    # >> stuff
+
+    def test_vargs_without_trailing_comma(self):
+        b = """print >>sys.stderr, 1, 2, 3"""
+        a = """print(1, 2, 3, file=sys.stderr)"""
+        self.check(b, a)
+
+    def test_with_trailing_comma(self):
+        b = """print >>sys.stderr, 1, 2,"""
+        a = """print(1, 2, end=' ', file=sys.stderr)"""
+        self.check(b, a)
+
+    def test_no_trailing_comma(self):
+        b = """print >>sys.stderr, 1+1"""
+        a = """print(1+1, file=sys.stderr)"""
+        self.check(b, a)
+
+    def test_spaces_before_file(self):
+        b = """print >>  sys.stderr"""
+        a = """print(file=sys.stderr)"""
+        self.check(b, a)
+
+    def test_with_future_print_function(self):
+        s = "from __future__ import print_function\n" \
+            "print('Hai!', end=' ')"
+        self.unchanged(s)
+
+        b = "print 'Hello, world!'"
+        a = "print('Hello, world!')"
+        self.check(b, a)
+
+
 # class Test_exec(FixerTestCase):
 #     fixer = "exec"
 # 
diff --git a/libfuturize/fixes/fix_print.py b/libfuturize/fixes/fix_print.py
@@ -0,0 +1,94 @@
+# Copyright 2006 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Fixer for print.
+
+Change:
+    "print"          into "print()"
+    "print ..."      into "print(...)"
+    "print(...)"     not changed
+    "print ... ,"    into "print(..., end=' ')"
+    "print >>x, ..." into "print(..., file=x)"
+
+No changes are applied if print_function is imported from __future__
+
+"""
+
+# Local imports
+from lib2to3 import patcomp, pytree, fixer_base
+from lib2to3.pgen2 import token
+from lib2to3.fixer_util import Name, Call, Comma, String
+# from libmodernize import add_future
+
+parend_expr = patcomp.compile_pattern(
+              """atom< '(' [arith_expr|atom|power|term|STRING|NAME] ')' >"""
+              )
+
+
+class FixPrint(fixer_base.BaseFix):
+
+    BM_compatible = True
+
+    PATTERN = """
+              simple_stmt< any* bare='print' any* > | print_stmt
+              """
+
+    def transform(self, node, results):
+        assert results
+
+        bare_print = results.get("bare")
+
+        if bare_print:
+            # Special-case print all by itself.
+            bare_print.replace(Call(Name(u"print"), [],
+                               prefix=bare_print.prefix))
+            # The "from __future__ import print_function"" declaration is added
+            # by the fix_print_with_import fixer, so we skip it here.
+            # add_future(node, u'print_function')
+            return
+        assert node.children[0] == Name(u"print")
+        args = node.children[1:]
+        if len(args) == 1 and parend_expr.match(args[0]):
+            # We don't want to keep sticking parens around an
+            # already-parenthesised expression.
+            return
+
+        sep = end = file = None
+        if args and args[-1] == Comma():
+            args = args[:-1]
+            end = " "
+        if args and args[0] == pytree.Leaf(token.RIGHTSHIFT, u">>"):
+            assert len(args) >= 2
+            file = args[1].clone()
+            args = args[3:] # Strip a possible comma after the file expression
+        # Now synthesize a print(args, sep=..., end=..., file=...) node.
+        l_args = [arg.clone() for arg in args]
+        if l_args:
+            l_args[0].prefix = u""
+        if sep is not None or end is not None or file is not None:
+            if sep is not None:
+                self.add_kwarg(l_args, u"sep", String(repr(sep)))
+            if end is not None:
+                self.add_kwarg(l_args, u"end", String(repr(end)))
+            if file is not None:
+                self.add_kwarg(l_args, u"file", file)
+        n_stmt = Call(Name(u"print"), l_args)
+        n_stmt.prefix = node.prefix
+
+        # Note that there are corner cases where adding this future-import is
+        # incorrect, for example when the file also has a 'print ()' statement
+        # that was intended to print "()".
+        # add_future(node, u'print_function')
+        return n_stmt
+
+    def add_kwarg(self, l_nodes, s_kwd, n_expr):
+        # XXX All this prefix-setting may lose comments (though rarely)
+        n_expr.prefix = u""
+        n_argument = pytree.Node(self.syms.argument,
+                                 (Name(s_kwd),
+                                  pytree.Leaf(token.EQUAL, u"="),
+                                  n_expr))
+        if l_nodes:
+            l_nodes.append(Comma())
+            n_argument.prefix = u" "
+        l_nodes.append(n_argument)
diff --git a/libfuturize/fixes/fix_print_with_import.py b/libfuturize/fixes/fix_print_with_import.py
@@ -8,7 +8,7 @@
 at the top to retain compatibility with Python 2.6+.
 """
 
-from lib2to3.fixes.fix_print import FixPrint
+from libfuturize.fixes.fix_print import FixPrint
 from libfuturize.fixer_util import future_import
 
 class FixPrintWithImport(FixPrint):
