Support types with parens around them

While the parens would be redundant, this is actually allowed in Python.

Merge `__convert_type_hint` into `__convert_type`.

Author: knutwannheden

rewrite/rewrite/python/_parser_visitor.py

@@ -138,7 +138,7 @@ def map_arg(self, node, default=None, vararg=False, kwarg=False):
         vararg_prefix = self.__source_before('*') if vararg else None
         name = self.__convert_name(node.arg, self.__map_type(node))
         after_name = self.__source_before(':') if node.annotation else Space.EMPTY
-        type_expression = self.__convert_type_hint(node.annotation) if node.annotation else None
+        type_expression = self.__convert_type(node.annotation) if node.annotation else None
         initializer = self.__pad_left(self.__source_before('='), self.__convert(default)) if default else None
 
         return j.VariableDeclarations(
@@ -297,7 +297,7 @@ def visit_AnnAssign(self, node):
                         random_id(),
                         self.__source_before(':'),
                         Markers.EMPTY,
-                        self.__convert_type_hint(node.annotation),
+                        self.__convert_type(node.annotation),
                         self.__map_type(node.annotation)
                     ),
                     self.__map_type(node)
@@ -312,7 +312,7 @@ def visit_AnnAssign(self, node):
             name = cast(j.Identifier, self.__convert(node.target))
             if node.annotation:
                 after = self.__source_before(':')
-                type = self.__convert_type_hint(node.annotation)
+                type = self.__convert_type(node.annotation)
             else:
                 after = Space.EMPTY
                 type = None
@@ -446,7 +446,8 @@ def visit_With(self, node):
         parenthesized = self.__cursor_at('(')
         parens_handler = self.__push_parentheses(node, items_prefix, self._cursor) if parenthesized else None
 
-        resources = [self.__pad_list_element(self.__convert(r), i == len(node.items) - 1) for i, r in enumerate(node.items)]
+        resources = [self.__pad_list_element(self.__convert(r), i == len(node.items) - 1) for i, r in
+                     enumerate(node.items)]
 
         if parenthesized and self._parentheses_stack and self._parentheses_stack[-1] is parens_handler:
             self._cursor += 1
@@ -778,7 +779,8 @@ def visit_Store(self, node):
 
     def visit_ExceptHandler(self, node):
         prefix = self.__source_before('except')
-        except_type = self.__convert_type(node.type) if node.type else j.Empty(random_id(), Space.EMPTY, Markers.EMPTY)
+        except_type = self.__convert_type(node.type) if node.type else j.Empty(random_id(), Space.EMPTY,
+                                                                               Markers.EMPTY)
         if node.name:
             before_as = self.__source_before('as')
             except_type_name = self.__convert_name(node.name)
@@ -1174,7 +1176,8 @@ def visit_Call(self, node):
             Markers.EMPTY,
             select if isinstance(name, j.Identifier) else self.__pad_right(name, Space.EMPTY),
             None,
-            name if isinstance(name, j.Identifier) else j.Identifier(random_id(), Space.EMPTY, Markers.EMPTY, [], "", None, None),
+            name if isinstance(name, j.Identifier) else j.Identifier(random_id(), Space.EMPTY, Markers.EMPTY, [], "",
+                                                                     None, None),
             args,
             self.__map_type(node)
         )
@@ -1784,7 +1787,7 @@ def visit_UnaryOp(self, node):
             self.__map_type(node)
         )
 
-    def __convert_type_hint(self, node) -> Optional[TypeTree]:
+    def __convert_type(self, node) -> Optional[TypeTree]:
         if isinstance(node, ast.Constant):
             if node.value is None or node.value is Ellipsis:
                 return py.LiteralType(
@@ -1825,7 +1828,7 @@ def __convert_type_hint(self, node) -> Optional[TypeTree]:
                 self.__convert(node.value),
                 JContainer(
                     self.__source_before('['),
-                    [self.__pad_list_element(self.__convert_type_hint(s), last=i == len(slices) - 1, end_delim=']') for
+                    [self.__pad_list_element(self.__convert_type(s), last=i == len(slices) - 1, end_delim=']') for
                      i, s in
                      enumerate(slices)],
                     Markers.EMPTY
@@ -1837,9 +1840,9 @@ def __convert_type_hint(self, node) -> Optional[TypeTree]:
             # NOTE: Type unions using `|` was added in Python 3.10
             prefix = self.__whitespace()
             # FIXME consider flattening nested unions
-            left = self.__pad_right(self.__convert_internal(node.left, self.__convert_type_hint),
+            left = self.__pad_right(self.__convert_internal(node.left, self.__convert_type),
                                     self.__source_before('|'))
-            right = self.__pad_right(self.__convert_internal(node.right, self.__convert_type_hint), Space.EMPTY)
+            right = self.__pad_right(self.__convert_internal(node.right, self.__convert_type), Space.EMPTY)
             return py.UnionType(
                 random_id(),
                 prefix,
@@ -1848,12 +1851,6 @@ def __convert_type_hint(self, node) -> Optional[TypeTree]:
                 self.__map_type(node)
             )
 
-        return self.__convert_internal(node, self.__convert_type_hint)
-
-    def __convert(self, node) -> Optional[J]:
-        return self.__convert_internal(node, self.__convert)
-
-    def __convert_type(self, node) -> Optional[j.TypeTree]:
         prefix = self.__whitespace()
         converted_type = self.__convert_internal(node, self.__convert_type)
         if is_of_type(converted_type, TypeTree):
@@ -1874,6 +1871,9 @@ def __convert_type(self, node) -> Optional[j.TypeTree]:
                 converted_type
             )
 
+    def __convert(self, node) -> Optional[J]:
+        return self.__convert_internal(node, self.__convert)
+
     def __convert_internal(self, node, recursion) -> Optional[J]:
         if not node or not isinstance(node, ast.expr) or isinstance(node, ast.GeneratorExp):
             return self.visit(cast(ast.AST, node)) if node else None

rewrite/tests/python/all/method_declaration_test.py

@@ -125,6 +125,18 @@ def foo(**kwargs) :
     )
 
 
+def test_param_type_with_parens():
+    # language=python
+    rewrite_run(
+        python(
+            """\
+            def foo(i: (int)) :
+                pass
+            """
+        )
+    )
+
+
 def test_one_line():
     # language=python
     rewrite_run(python("def f(x): x = x + 1; return x"))