Track parentheses in patterns

Author: kddnewton

lib/prism/translation/ripper.rb

@@ -583,13 +583,23 @@ def visit_alias_global_variable_node(node)
       # foo => bar | baz
       #        ^^^^^^^^^
       def visit_alternation_pattern_node(node)
-        left = visit(node.left)
-        right = visit(node.right)
+        left = visit_pattern_node(node.left)
+        right = visit_pattern_node(node.right)
 
         bounds(node.location)
         on_binary(left, :|, right)
       end
 
+      # Visit a pattern within a pattern match. This is used to bypass the
+      # parenthesis node that can be used to wrap patterns.
+      private def visit_pattern_node(node)
+        if node.is_a?(ParenthesesNode)
+          visit(node.body)
+        else
+          visit(node)
+        end
+      end
+
       # a and b
       # ^^^^^^^
       def visit_and_node(node)
@@ -1952,7 +1962,7 @@ def visit_in_node(node)
         # This is a special case where we're not going to call on_in directly
         # because we don't have access to the consequent. Instead, we'll return
         # the component parts and let the parent node handle it.
-        pattern = visit(node.pattern)
+        pattern = visit_pattern_node(node.pattern)
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -2389,7 +2399,7 @@ def visit_match_last_line_node(node)
       # ^^^^^^^^^^
       def visit_match_predicate_node(node)
         value = visit(node.value)
-        pattern = on_in(visit(node.pattern), nil, nil)
+        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
 
         on_case(value, pattern)
       end
@@ -2398,7 +2408,7 @@ def visit_match_predicate_node(node)
       # ^^^^^^^^^^
       def visit_match_required_node(node)
         value = visit(node.value)
-        pattern = on_in(visit(node.pattern), nil, nil)
+        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
 
         on_case(value, pattern)
       end

src/prism.c

@@ -14883,14 +14883,20 @@ parse_pattern_primitives(pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
                 break;
             }
             case PM_TOKEN_PARENTHESIS_LEFT: {
+                pm_token_t opening = parser->current;
                 parser_lex(parser);
-                if (node != NULL) {
-                    pm_node_destroy(parser, node);
-                }
-                node = parse_pattern(parser, false, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN);
 
+                pm_node_t *body = parse_pattern(parser, false, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN);
                 accept1(parser, PM_TOKEN_NEWLINE);
                 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN);
+                pm_node_t *right = (pm_node_t *) pm_parentheses_node_create(parser, &opening, body, &parser->previous);
+
+                if (node == NULL) {
+                    node = right;
+                } else {
+                    node = (pm_node_t *) pm_alternation_pattern_node_create(parser, node, right, &operator);
+                }
+
                 break;
             }
             default: {