[ruby/prism] Add a "repeated flag" to parameter nodes

It's possible to repeat parameters in method definitions like so:

```ruby
def foo(_a, _a)
end
```

The compiler needs to know to adjust the local table size to account for
these duplicate names.  We'll use the repeated parameter flag to account
for the extra stack space required

https://github.com/ruby/prism/commit/b443cb1f60

Co-Authored-By: Kevin Newton <kddnewton@gmail.com>
Co-Authored-By: Jemma Issroff <jemmaissroff@gmail.com>

lib/prism/debug.rb

@@ -138,12 +138,14 @@ module Prism
               *params.keywords.grep(OptionalKeywordParameterNode).map(&:name),
             ]
 
+            sorted << AnonymousLocal if params.keywords.any?
+
             if params.keyword_rest.is_a?(ForwardingParameterNode)
               sorted.push(:*, :&, :"...")
+            elsif params.keyword_rest.is_a?(KeywordRestParameterNode)
+              sorted << params.keyword_rest.name if params.keyword_rest.name
             end
 
-            sorted << AnonymousLocal if params.keywords.any?
-
             # Recurse down the parameter tree to find any destructured
             # parameters and add them after the other parameters.
             param_stack = params.requireds.concat(params.posts).grep(MultiTargetNode).reverse
@@ -151,15 +153,17 @@ module Prism
               case param
               when MultiTargetNode
                 param_stack.concat(param.rights.reverse)
-                param_stack << param.rest
+                param_stack << param.rest if param.rest&.expression && !sorted.include?(param.rest.expression.name)
                 param_stack.concat(param.lefts.reverse)
               when RequiredParameterNode
                 sorted << param.name
               when SplatNode
-                sorted << param.expression.name if param.expression
+                sorted << param.expression.name
               end
             end
 
+            sorted << params.block.name if params.block&.name
+
             names = sorted.concat(names - sorted)
           end
 

prism/config.yml

@@ -378,6 +378,11 @@ flags:
       - name: BEGIN_MODIFIER
         comment: "a loop after a begin statement, so the body is executed first before the condition"
     comment: Flags for while and until loop nodes.
+  - name: ParameterFlags
+    values:
+      - name: REPEATED_PARAMETER
+        comment: "a parameter name that has been repeated in the method signature"
+    comment: Flags for parameter nodes.
   - name: RangeFlags
     values:
       - name: EXCLUDE_END
@@ -648,6 +653,9 @@ nodes:
           ^^^^^^^^^^
   - name: BlockLocalVariableNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant
     comment: |
@@ -676,6 +684,9 @@ nodes:
                      ^^^^^^^^^^^^^^
   - name: BlockParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant?
       - name: name_loc
@@ -1923,6 +1934,9 @@ nodes:
               ^^^^
   - name: KeywordRestParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant?
       - name: name_loc
@@ -2221,6 +2235,9 @@ nodes:
           ^^
   - name: OptionalKeywordParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant
       - name: name_loc
@@ -2235,6 +2252,9 @@ nodes:
           end
   - name: OptionalParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant
       - name: name_loc
@@ -2451,6 +2471,9 @@ nodes:
           ^^^^^^
   - name: RequiredKeywordParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant
       - name: name_loc
@@ -2463,6 +2486,9 @@ nodes:
           end
   - name: RequiredParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant
     comment: |
@@ -2514,6 +2540,9 @@ nodes:
       `ex` is in the `exception` field.
   - name: RestParameterNode
     fields:
+      - name: flags
+        type: flags
+        kind: ParameterFlags
       - name: name
         type: constant?
       - name: name_loc

prism/prism.c

@@ -887,6 +887,27 @@ pm_node_flag_unset(pm_node_t *node, pm_node_flags_t flag) {
     node->flags &= (pm_node_flags_t) ~flag;
 }
 
+/**
+ * Set the repeated parameter flag on the given node.
+ */
+static inline void
+pm_node_flag_set_repeated_parameter(pm_node_t *node) {
+    switch (PM_NODE_TYPE(node)) {
+        case PM_BLOCK_LOCAL_VARIABLE_NODE:
+        case PM_BLOCK_PARAMETER_NODE:
+        case PM_KEYWORD_REST_PARAMETER_NODE:
+        case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
+        case PM_OPTIONAL_PARAMETER_NODE:
+        case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
+        case PM_REQUIRED_PARAMETER_NODE:
+        case PM_REST_PARAMETER_NODE:
+            pm_node_flag_set(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER);
+            break;
+        default:
+            fprintf(stderr, "unhandled type %d\n", PM_NODE_TYPE(node));
+            abort();
+    };
+}
 
 /******************************************************************************/
 /* Node creation functions                                                    */
@@ -5996,22 +6017,24 @@ pm_parser_local_add_owned(pm_parser_t *parser, const uint8_t *start, size_t leng
  * Add a parameter name to the current scope and check whether the name of the
  * parameter is unique or not.
  */
-static void
+static bool
 pm_parser_parameter_name_check(pm_parser_t *parser, const pm_token_t *name) {
     // We want to check whether the parameter name is a numbered parameter or
     // not.
     pm_refute_numbered_parameter(parser, name->start, name->end);
 
-    // We want to ignore any parameter name that starts with an underscore.
-    if ((name->start < name->end) && (*name->start == '_')) return;
-
     // Otherwise we'll fetch the constant id for the parameter name and check
     // whether it's already in the current scope.
     pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, name);
 
     if (pm_constant_id_list_includes(&parser->current_scope->locals, constant_id)) {
-        pm_parser_err_token(parser, name, PM_ERR_PARAMETER_NAME_REPEAT);
+        // Add an error if the parameter doesn't start with _ and has been seen before
+        if ((name->start < name->end) && (*name->start != '_')) {
+            pm_parser_err_token(parser, name, PM_ERR_PARAMETER_NAME_REPEAT);
+        }
+        return true;
     }
+    return false;
 }
 
 /**
@@ -11466,7 +11489,9 @@ parse_required_destructured_parameter(pm_parser_t *parser) {
             if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                 pm_token_t name = parser->previous;
                 value = (pm_node_t *) pm_required_parameter_node_create(parser, &name);
-                pm_parser_parameter_name_check(parser, &name);
+                if (pm_parser_parameter_name_check(parser, &name)) {
+                    pm_node_flag_set_repeated_parameter(value);
+                }
                 pm_parser_local_add_token(parser, &name);
             }
 
@@ -11476,7 +11501,9 @@ parse_required_destructured_parameter(pm_parser_t *parser) {
             pm_token_t name = parser->previous;
 
             param = (pm_node_t *) pm_required_parameter_node_create(parser, &name);
-            pm_parser_parameter_name_check(parser, &name);
+            if (pm_parser_parameter_name_check(parser, &name)) {
+                pm_node_flag_set_repeated_parameter(param);
+            }
             pm_parser_local_add_token(parser, &name);
         }
 
@@ -11593,9 +11620,10 @@ parse_parameters(
                 pm_token_t operator = parser->previous;
                 pm_token_t name;
 
+                bool repeated = false;
                 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                     name = parser->previous;
-                    pm_parser_parameter_name_check(parser, &name);
+                    repeated = pm_parser_parameter_name_check(parser, &name);
                     pm_parser_local_add_token(parser, &name);
                 } else {
                     name = not_provided(parser);
@@ -11606,6 +11634,9 @@ parse_parameters(
                 }
 
                 pm_block_parameter_node_t *param = pm_block_parameter_node_create(parser, &name, &operator);
+                if (repeated) {
+                    pm_node_flag_set_repeated_parameter((pm_node_t *)param);
+                }
                 if (params->block == NULL) {
                     pm_parameters_node_block_set(params, param);
                 } else {
@@ -11678,7 +11709,7 @@ parse_parameters(
                 }
 
                 pm_token_t name = parser->previous;
-                pm_parser_parameter_name_check(parser, &name);
+                bool repeated = pm_parser_parameter_name_check(parser, &name);
                 pm_parser_local_add_token(parser, &name);
 
                 if (accept1(parser, PM_TOKEN_EQUAL)) {
@@ -11689,6 +11720,9 @@ parse_parameters(
                     pm_node_t *value = parse_value_expression(parser, binding_power, false, PM_ERR_PARAMETER_NO_DEFAULT);
 
                     pm_optional_parameter_node_t *param = pm_optional_parameter_node_create(parser, &name, &operator, value);
+                    if (repeated) {
+                        pm_node_flag_set_repeated_parameter((pm_node_t *)param);
+                    }
                     pm_parameters_node_optionals_append(params, param);
 
                     parser->current_param_name = old_param_name;
@@ -11703,9 +11737,15 @@ parse_parameters(
                     }
                 } else if (order > PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
                     pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
+                    if (repeated) {
+                        pm_node_flag_set_repeated_parameter((pm_node_t *)param);
+                    }
                     pm_parameters_node_requireds_append(params, (pm_node_t *) param);
                 } else {
                     pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
+                    if (repeated) {
+                        pm_node_flag_set_repeated_parameter((pm_node_t *)param);
+                    }
                     pm_parameters_node_posts_append(params, (pm_node_t *) param);
                 }
 
@@ -11720,7 +11760,7 @@ parse_parameters(
                 pm_token_t local = name;
                 local.end -= 1;
 
-                pm_parser_parameter_name_check(parser, &local);
+                bool repeated = pm_parser_parameter_name_check(parser, &local);
                 pm_parser_local_add_token(parser, &local);
 
                 switch (parser->current.type) {
@@ -11728,6 +11768,9 @@ parse_parameters(
                     case PM_TOKEN_PARENTHESIS_RIGHT:
                     case PM_TOKEN_PIPE: {
                         pm_node_t *param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
+                        if (repeated) {
+                            pm_node_flag_set_repeated_parameter(param);
+                        }
                         pm_parameters_node_keywords_append(params, param);
                         break;
                     }
@@ -11739,6 +11782,9 @@ parse_parameters(
                         }
 
                         pm_node_t *param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
+                        if (repeated) {
+                            pm_node_flag_set_repeated_parameter(param);
+                        }
                         pm_parameters_node_keywords_append(params, param);
                         break;
                     }
@@ -11758,6 +11804,9 @@ parse_parameters(
                             param = (pm_node_t *) pm_required_keyword_parameter_node_create(parser, &name);
                         }
 
+                        if (repeated) {
+                            pm_node_flag_set_repeated_parameter(param);
+                        }
                         pm_parameters_node_keywords_append(params, param);
 
                         // If parsing the value of the parameter resulted in error recovery,
@@ -11780,10 +11829,10 @@ parse_parameters(
 
                 pm_token_t operator = parser->previous;
                 pm_token_t name;
-
+                bool repeated = false;
                 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                     name = parser->previous;
-                    pm_parser_parameter_name_check(parser, &name);
+                    repeated = pm_parser_parameter_name_check(parser, &name);
                     pm_parser_local_add_token(parser, &name);
                 } else {
                     name = not_provided(parser);
@@ -11794,6 +11843,9 @@ parse_parameters(
                 }
 
                 pm_node_t *param = (pm_node_t *) pm_rest_parameter_node_create(parser, &operator, &name);
+                if (repeated) {
+                    pm_node_flag_set_repeated_parameter(param);
+                }
                 if (params->rest == NULL) {
                     pm_parameters_node_rest_set(params, param);
                 } else {
@@ -11816,9 +11868,10 @@ parse_parameters(
                 } else {
                     pm_token_t name;
 
+                    bool repeated = false;
                     if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
                         name = parser->previous;
-                        pm_parser_parameter_name_check(parser, &name);
+                        repeated = pm_parser_parameter_name_check(parser, &name);
                         pm_parser_local_add_token(parser, &name);
                     } else {
                         name = not_provided(parser);
@@ -11829,6 +11882,9 @@ parse_parameters(
                     }
 
                     param = (pm_node_t *) pm_keyword_rest_parameter_node_create(parser, &operator, &name);
+                    if (repeated) {
+                        pm_node_flag_set_repeated_parameter(param);
+                    }
                 }
 
                 if (params->keyword_rest == NULL) {
@@ -12064,10 +12120,13 @@ parse_block_parameters(
     if ((opening->type != PM_TOKEN_NOT_PROVIDED) && accept1(parser, PM_TOKEN_SEMICOLON)) {
         do {
             expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE);
-            pm_parser_parameter_name_check(parser, &parser->previous);
+            bool repeated = pm_parser_parameter_name_check(parser, &parser->previous);
             pm_parser_local_add_token(parser, &parser->previous);
 
             pm_block_local_variable_node_t *local = pm_block_local_variable_node_create(parser, &parser->previous);
+            if (repeated) {
+                pm_node_flag_set_repeated_parameter((pm_node_t *)local);
+            }
             pm_block_parameters_node_append_local(block_parameters, local);
         } while (accept1(parser, PM_TOKEN_COMMA));
     }

test/prism/errors_test.rb

@@ -566,10 +566,10 @@ module Prism
         Location(),
         nil,
         ParametersNode([
-          RequiredParameterNode(:A),
+          RequiredParameterNode(0, :A),
-          RequiredParameterNode(:@a),
+          RequiredParameterNode(0, :@a),
-          RequiredParameterNode(:$A),
+          RequiredParameterNode(0, :$A),
-          RequiredParameterNode(:@@a),
+          RequiredParameterNode(0, :@@a),
         ], [], nil, [], [], nil, nil),
         nil,
         [:A, :@a, :$A, :@@a],
@@ -635,7 +635,7 @@ module Prism
         Location(),
         nil,
         ParametersNode(
-          [RequiredParameterNode(:a), RequiredParameterNode(:b), RequiredParameterNode(:c)],
+          [RequiredParameterNode(0, :a), RequiredParameterNode(0, :b), RequiredParameterNode(0, :c)],
           [],
           nil,
           [],
@@ -667,7 +667,7 @@ module Prism
         Location(),
         Location(),
         BlockParametersNode(
-          ParametersNode([RequiredParameterNode(:a), RequiredParameterNode(:b)], [], nil, [], [], nil, nil),
+          ParametersNode([RequiredParameterNode(0, :a), RequiredParameterNode(0, :b)], [], nil, [], [], nil, nil),
           [],
           Location(),
           Location()
@@ -724,10 +724,10 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
           [],
           nil,
-          BlockParameterNode(:block, Location(), Location())
+          BlockParameterNode(0, :block, Location(), Location())
         ),
         nil,
         [:block, :a],
@@ -749,7 +749,7 @@ module Prism
         :foo,
         Location(),
         nil,
-        ParametersNode([], [], nil, [RequiredParameterNode(:a)], [], nil, BlockParameterNode(nil, nil, Location())),
+        ParametersNode([], [], nil, [RequiredParameterNode(0, :a)], [], nil, BlockParameterNode(0, nil, nil, Location())),
         nil,
         [:&, :a],
         2,
@@ -775,7 +775,7 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
           [],
           ForwardingParameterNode(),
           nil
@@ -804,8 +804,8 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
-          [RequiredKeywordParameterNode(:b, Location())],
+          [RequiredKeywordParameterNode(0, :b, Location())],
           nil,
           nil
         ),
@@ -834,8 +834,8 @@ module Prism
           [],
           nil,
           [],
-          [RequiredKeywordParameterNode(:b, Location())],
+          [RequiredKeywordParameterNode(0, :b, Location())],
-          KeywordRestParameterNode(:rest, Location(), Location()),
+          KeywordRestParameterNode(0, :rest, Location(), Location()),
           nil
         ),
         nil,
@@ -885,9 +885,9 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
-          [RequiredKeywordParameterNode(:b, Location())],
+          [RequiredKeywordParameterNode(0, :b, Location())],
-          KeywordRestParameterNode(:args, Location(), Location()),
+          KeywordRestParameterNode(0, :args, Location(), Location()),
           nil
         ),
         nil,
@@ -916,9 +916,9 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
-          [RequiredKeywordParameterNode(:b, Location())],
+          [RequiredKeywordParameterNode(0, :b, Location())],
-          KeywordRestParameterNode(:args, Location(), Location()),
+          KeywordRestParameterNode(0, :args, Location(), Location()),
           nil
         ),
         nil,
@@ -947,9 +947,9 @@ module Prism
           [],
           [],
           nil,
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
-          [RequiredKeywordParameterNode(:b, Location())],
+          [RequiredKeywordParameterNode(0, :b, Location())],
-          KeywordRestParameterNode(:args, Location(), Location()),
+          KeywordRestParameterNode(0, :args, Location(), Location()),
           nil
         ),
         nil,
@@ -975,13 +975,13 @@ module Prism
         Location(),
         nil,
         ParametersNode(
-          [RequiredParameterNode(:a)],
+          [RequiredParameterNode(0, :a)],
           [
-            OptionalParameterNode(:b, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL)),
+            OptionalParameterNode(0, :b, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL)),
-            OptionalParameterNode(:d, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL))
+            OptionalParameterNode(0, :d, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL))
           ],
           nil,
-          [RequiredParameterNode(:c), RequiredParameterNode(:e)],
+          [RequiredParameterNode(0, :c), RequiredParameterNode(0, :e)],
           [],
           nil,
           nil
@@ -1152,7 +1152,7 @@ module Prism
           :foo,
           Location(),
           nil,
-          ParametersNode([RequiredParameterNode(:a), RequiredParameterNode(:b), RequiredParameterNode(:a)], [], nil, [], [], nil, nil),
+          ParametersNode([RequiredParameterNode(0, :a), RequiredParameterNode(0, :b), RequiredParameterNode(ParameterFlags::REPEATED_PARAMETER, :a)], [], nil, [], [], nil, nil),
           nil,
           [:a, :b],
           2,
@@ -1173,7 +1173,7 @@ module Prism
         :foo,
         Location(),
         nil,
-        ParametersNode([RequiredParameterNode(:a), RequiredParameterNode(:b)], [], RestParameterNode(:a, Location(), Location()), [], [], nil, nil),
+        ParametersNode([RequiredParameterNode(0, :a), RequiredParameterNode(0, :b)], [], RestParameterNode(ParameterFlags::REPEATED_PARAMETER, :a, Location(), Location()), [], [], nil, nil),
         nil,
         [:a, :b],
         2,
@@ -1193,7 +1193,7 @@ module Prism
         :foo,
         Location(),
         nil,
-        ParametersNode([RequiredParameterNode(:a), RequiredParameterNode(:b)], [], nil, [], [], KeywordRestParameterNode(:a, Location(), Location()), nil),
+        ParametersNode([RequiredParameterNode(0, :a), RequiredParameterNode(0, :b)], [], nil, [], [], KeywordRestParameterNode(ParameterFlags::REPEATED_PARAMETER, :a, Location(), Location()), nil),
         nil,
         [:a, :b],
         2,
@@ -1213,7 +1213,7 @@ module Prism
         :foo,
         Location(),
         nil,
-        ParametersNode([RequiredParameterNode(:a), RequiredParameterNode(:b)], [], nil, [], [], nil, BlockParameterNode(:a, Location(), Location())),
+        ParametersNode([RequiredParameterNode(0, :a), RequiredParameterNode(0, :b)], [], nil, [], [], nil, BlockParameterNode(ParameterFlags::REPEATED_PARAMETER, :a, Location(), Location())),
         nil,
         [:a, :b],
         2,
@@ -1233,7 +1233,7 @@ module Prism
         :foo,
         Location(),
         nil,
-        ParametersNode([], [OptionalParameterNode(:a, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL))], RestParameterNode(:c, Location(), Location()), [RequiredParameterNode(:b)], [], nil, nil),
+        ParametersNode([], [OptionalParameterNode(0, :a, Location(), Location(), IntegerNode(IntegerBaseFlags::DECIMAL))], RestParameterNode(0, :c, Location(), Location()), [RequiredParameterNode(0, :b)], [], nil, nil),
         nil,
         [:a, :b, :c],
         3,

test/prism/fixtures/methods.txt

@@ -161,9 +161,6 @@ def method(a)
   item >> a {}
 end
 
-def foo(_a, _a, b, c)
-end
-
 foo = 1
 def foo.bar; end
 

test/prism/fixtures/repeat_parameters.txt

@@ -0,0 +1,38 @@
+def foo(a, _)
+end
+
+def foo(a, _, _)
+end
+
+def foo(a, _, _, _b)
+end
+
+def foo(a, _, _, _b, _b)
+end
+
+def foo(a, (b, *_c, d), (e, *_c, f))
+end
+
+def foo(_a, _a, b, c)
+end
+
+def foo((a, *_b, c), (d, *_b, e))
+end
+
+def foo(_a = 1, _a = 2)
+end
+
+def foo(_a:, _a:)
+end
+
+def foo(_a: 1, _a: 2)
+end
+
+def foo(_a, **_a)
+end
+
+def foo(_a, &_a)
+end
+
+def foo(_a, *_a)
+end

test/prism/snapshots/arrays.txt

@@ -1031,6 +1031,7 @@
         │   │   ├── keyword_rest: ∅
         │   │   └── block:
         │   │       @ BlockParameterNode (location: (88,8)-(88,9))
+        │   │       ├── flags: ∅
         │   │       ├── name: ∅
         │   │       ├── name_loc: ∅
         │   │       └── operator_loc: (88,8)-(88,9) = "&"
@@ -1809,6 +1810,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (128,6)-(128,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (128,6)-(128,7) = "*"
@@ -1863,6 +1865,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (130,6)-(130,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (130,6)-(130,7) = "*"
@@ -1919,6 +1922,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (132,6)-(132,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (132,6)-(132,7) = "*"
@@ -1975,6 +1979,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (134,6)-(134,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (134,6)-(134,7) = "*"
@@ -2033,6 +2038,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (136,6)-(136,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (136,6)-(136,7) = "*"
@@ -2090,6 +2096,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (138,6)-(138,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (138,6)-(138,7) = "*"
@@ -2148,6 +2155,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (140,6)-(140,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (140,6)-(140,7) = "*"
@@ -2211,6 +2219,7 @@
             │   ├── optionals: (length: 0)
             │   ├── rest:
             │   │   @ RestParameterNode (location: (142,6)-(142,7))
+            │   │   ├── flags: ∅
             │   │   ├── name: ∅
             │   │   ├── name_loc: ∅
             │   │   └── operator_loc: (142,6)-(142,7) = "*"

test/prism/snapshots/blocks.txt

@@ -141,8 +141,10 @@
         │       │   │   @ ParametersNode (location: (7,15)-(7,22))
         │       │   │   ├── requireds: (length: 2)
         │       │   │   │   ├── @ RequiredParameterNode (location: (7,15)-(7,16))
+        │       │   │   │   │   ├── flags: ∅
         │       │   │   │   │   └── name: :x
         │       │   │   │   └── @ RequiredParameterNode (location: (7,18)-(7,22))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :memo
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅
@@ -324,6 +326,7 @@
         │       │   │   ├── requireds: (length: 0)
         │       │   │   ├── optionals: (length: 1)
         │       │   │   │   └── @ OptionalParameterNode (location: (17,8)-(17,16))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       ├── name: :a
         │       │   │   │       ├── name_loc: (17,8)-(17,9) = "a"
         │       │   │   │       ├── operator_loc: (17,10)-(17,11) = "="
@@ -521,9 +524,11 @@
         │       │   │   @ ParametersNode (location: (33,7)-(33,19))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (33,7)-(33,8))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :x
         │       │   │   ├── optionals: (length: 1)
         │       │   │   │   └── @ OptionalParameterNode (location: (33,10)-(33,15))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       ├── name: :y
         │       │   │   │       ├── name_loc: (33,10)-(33,11) = "y"
         │       │   │   │       ├── operator_loc: (33,12)-(33,13) = "="
@@ -534,6 +539,7 @@
         │       │   │   ├── posts: (length: 0)
         │       │   │   ├── keywords: (length: 1)
         │       │   │   │   └── @ RequiredKeywordParameterNode (location: (33,17)-(33,19))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       ├── name: :z
         │       │   │   │       └── name_loc: (33,17)-(33,19) = "z:"
         │       │   │   ├── keyword_rest: ∅
@@ -568,6 +574,7 @@
         │       │   │   @ ParametersNode (location: (35,7)-(35,8))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (35,7)-(35,8))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :x
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅
@@ -608,6 +615,7 @@
         │       │   │   @ ParametersNode (location: (38,9)-(38,10))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (38,9)-(38,10))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :a
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅
@@ -640,6 +648,7 @@
         │       │   │   @ ParametersNode (location: (41,8)-(41,9))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (41,8)-(41,9))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :a
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅
@@ -721,12 +730,14 @@
         │   │               │   │   ├── posts: (length: 0)
         │   │               │   │   ├── keywords: (length: 2)
         │   │               │   │   │   ├── @ OptionalKeywordParameterNode (location: (49,2)-(49,6))
+        │   │               │   │   │   │   ├── flags: ∅
         │   │               │   │   │   │   ├── name: :a
         │   │               │   │   │   │   ├── name_loc: (49,2)-(49,4) = "a:"
         │   │               │   │   │   │   └── value:
         │   │               │   │   │   │       @ IntegerNode (location: (49,5)-(49,6))
         │   │               │   │   │   │       └── flags: decimal
         │   │               │   │   │   └── @ OptionalKeywordParameterNode (location: (50,2)-(50,6))
+        │   │               │   │   │       ├── flags: ∅
         │   │               │   │   │       ├── name: :b
         │   │               │   │   │       ├── name_loc: (50,2)-(50,4) = "b:"
         │   │               │   │   │       └── value:
@@ -761,6 +772,7 @@
                 │   │   @ ParametersNode (location: (54,8)-(54,12))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (54,8)-(54,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :bar
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest:

test/prism/snapshots/break.txt

@@ -189,6 +189,7 @@
             │       │   │   @ ParametersNode (location: (25,7)-(25,8))
             │       │   │   ├── requireds: (length: 1)
             │       │   │   │   └── @ RequiredParameterNode (location: (25,7)-(25,8))
+            │       │   │   │       ├── flags: ∅
             │       │   │   │       └── name: :a
             │       │   │   ├── optionals: (length: 0)
             │       │   │   ├── rest: ∅

test/prism/snapshots/if.txt

@@ -356,6 +356,7 @@
             │               │   │   @ ParametersNode (location: (34,13)-(34,14))
             │               │   │   ├── requireds: (length: 1)
             │               │   │   │   └── @ RequiredParameterNode (location: (34,13)-(34,14))
+            │               │   │   │       ├── flags: ∅
             │               │   │   │       └── name: :_
             │               │   │   ├── optionals: (length: 0)
             │               │   │   ├── rest: ∅
@@ -398,6 +399,7 @@
             │   │               │   │   @ ParametersNode (location: (37,13)-(37,14))
             │   │               │   │   ├── requireds: (length: 1)
             │   │               │   │   │   └── @ RequiredParameterNode (location: (37,13)-(37,14))
+            │   │               │   │   │       ├── flags: ∅
             │   │               │   │   │       └── name: :_
             │   │               │   │   ├── optionals: (length: 0)
             │   │               │   │   ├── rest: ∅
@@ -436,6 +438,7 @@
             │   │   │               │   │   @ ParametersNode (location: (40,13)-(40,14))
             │   │   │               │   │   ├── requireds: (length: 1)
             │   │   │               │   │   │   └── @ RequiredParameterNode (location: (40,13)-(40,14))
+            │   │   │               │   │   │       ├── flags: ∅
             │   │   │               │   │   │       └── name: :_
             │   │   │               │   │   ├── optionals: (length: 0)
             │   │   │               │   │   ├── rest: ∅

test/prism/snapshots/keyword_method_names.txt

@@ -86,6 +86,7 @@
         │   │   @ ParametersNode (location: (12,6)-(12,14))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (12,6)-(12,7))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :a
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅

test/prism/snapshots/lambda.txt

@@ -15,6 +15,7 @@
         │   │   │   @ ParametersNode (location: (2,2)-(2,5))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (2,2)-(2,5))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :foo
         │   │   │   ├── optionals: (length: 0)
         │   │   │   ├── rest: ∅
@@ -42,6 +43,7 @@
         │   │   │   ├── posts: (length: 0)
         │   │   │   ├── keywords: (length: 1)
         │   │   │   │   └── @ OptionalKeywordParameterNode (location: (5,3)-(5,13))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :x
         │   │   │   │       ├── name_loc: (5,3)-(5,5) = "x:"
         │   │   │   │       └── value:
@@ -93,6 +95,7 @@
         │   │   │   ├── posts: (length: 0)
         │   │   │   ├── keywords: (length: 1)
         │   │   │   │   └── @ OptionalKeywordParameterNode (location: (7,3)-(7,11))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :a
         │   │   │   │       ├── name_loc: (7,3)-(7,5) = "a:"
         │   │   │   │       └── value:
@@ -140,6 +143,7 @@
         │   │   │   ├── requireds: (length: 0)
         │   │   │   ├── optionals: (length: 1)
         │   │   │   │   └── @ OptionalParameterNode (location: (9,3)-(9,12))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :foo
         │   │   │   │       ├── name_loc: (9,3)-(9,6) = "foo"
         │   │   │   │       ├── operator_loc: (9,7)-(9,8) = "="
@@ -179,6 +183,7 @@
             │   │   ├── posts: (length: 0)
             │   │   ├── keywords: (length: 1)
             │   │   │   └── @ OptionalKeywordParameterNode (location: (11,3)-(11,11))
+            │   │   │       ├── flags: ∅
             │   │   │       ├── name: :foo
             │   │   │       ├── name_loc: (11,3)-(11,7) = "foo:"
             │   │   │       └── value:

test/prism/snapshots/method_calls.txt

@@ -938,8 +938,10 @@
         │       │   │   @ ParametersNode (location: (64,20)-(64,24))
         │       │   │   ├── requireds: (length: 2)
         │       │   │   │   ├── @ RequiredParameterNode (location: (64,20)-(64,21))
+        │       │   │   │   │   ├── flags: ∅
         │       │   │   │   │   └── name: :a
         │       │   │   │   └── @ RequiredParameterNode (location: (64,23)-(64,24))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :b
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅
@@ -1932,6 +1934,7 @@
         │   │           │               │   │   @ ParametersNode (location: (121,12)-(121,13))
         │   │           │               │   │   ├── requireds: (length: 1)
         │   │           │               │   │   │   └── @ RequiredParameterNode (location: (121,12)-(121,13))
+        │   │           │               │   │   │       ├── flags: ∅
         │   │           │               │   │   │       └── name: :a
         │   │           │               │   │   ├── optionals: (length: 0)
         │   │           │               │   │   ├── rest: ∅
@@ -2008,6 +2011,7 @@
         │   │       │                   │   │   @ ParametersNode (location: (128,12)-(128,13))
         │   │       │                   │   │   ├── requireds: (length: 1)
         │   │       │                   │   │   │   └── @ RequiredParameterNode (location: (128,12)-(128,13))
+        │   │       │                   │   │   │       ├── flags: ∅
         │   │       │                   │   │   │       └── name: :a
         │   │       │                   │   │   ├── optionals: (length: 0)
         │   │       │                   │   │   ├── rest: ∅
@@ -2131,6 +2135,7 @@
         │   │               │   │   @ ParametersNode (location: (139,10)-(139,11))
         │   │               │   │   ├── requireds: (length: 1)
         │   │               │   │   │   └── @ RequiredParameterNode (location: (139,10)-(139,11))
+        │   │               │   │   │       ├── flags: ∅
         │   │               │   │   │       └── name: :a
         │   │               │   │   ├── optionals: (length: 0)
         │   │               │   │   ├── rest: ∅
@@ -2309,6 +2314,7 @@
             │   ├── optionals: (length: 0)
             │   ├── rest:
             │   │   @ RestParameterNode (location: (149,6)-(149,7))
+            │   │   ├── flags: ∅
             │   │   ├── name: ∅
             │   │   ├── name_loc: ∅
             │   │   └── operator_loc: (149,6)-(149,7) = "*"

test/prism/snapshots/methods.txt

@@ -1,8 +1,8 @@
-@ ProgramNode (location: (1,0)-(186,37))
+@ ProgramNode (location: (1,0)-(183,37))
 ├── locals: [:a, :c, :foo]
 └── statements:
-    @ StatementsNode (location: (1,0)-(186,37))
+    @ StatementsNode (location: (1,0)-(183,37))
-    └── body: (length: 70)
+    └── body: (length: 69)
         ├── @ DefNode (location: (1,0)-(2,3))
         │   ├── name: :foo
         │   ├── name_loc: (1,4)-(1,7) = "foo"
@@ -13,8 +13,10 @@
         │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,18))
         │   │   │       ├── lefts: (length: 2)
         │   │   │       │   ├── @ RequiredParameterNode (location: (1,9)-(1,12))
+        │   │   │       │   │   ├── flags: ∅
         │   │   │       │   │   └── name: :bar
         │   │   │       │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
+        │   │   │       │       ├── flags: ∅
         │   │   │       │       └── name: :baz
         │   │   │       ├── rest: ∅
         │   │   │       ├── rights: (length: 0)
@@ -45,8 +47,10 @@
         │   │   │   └── @ MultiTargetNode (location: (4,8)-(4,18))
         │   │   │       ├── lefts: (length: 2)
         │   │   │       │   ├── @ RequiredParameterNode (location: (4,9)-(4,12))
+        │   │   │       │   │   ├── flags: ∅
         │   │   │       │   │   └── name: :bar
         │   │   │       │   └── @ RequiredParameterNode (location: (4,14)-(4,17))
+        │   │   │       │       ├── flags: ∅
         │   │   │       │       └── name: :baz
         │   │   │       ├── rest: ∅
         │   │   │       ├── rights: (length: 0)
@@ -54,6 +58,7 @@
         │   │   │       └── rparen_loc: (4,17)-(4,18) = ")"
         │   │   ├── optionals: (length: 1)
         │   │   │   └── @ OptionalParameterNode (location: (4,20)-(4,32))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :optional
         │   │   │       ├── name_loc: (4,20)-(4,28) = "optional"
         │   │   │       ├── operator_loc: (4,29)-(4,30) = "="
@@ -65,8 +70,10 @@
         │   │   │   └── @ MultiTargetNode (location: (4,34)-(4,44))
         │   │   │       ├── lefts: (length: 2)
         │   │   │       │   ├── @ RequiredParameterNode (location: (4,35)-(4,38))
+        │   │   │       │   │   ├── flags: ∅
         │   │   │       │   │   └── name: :bin
         │   │   │       │   └── @ RequiredParameterNode (location: (4,40)-(4,43))
+        │   │   │       │       ├── flags: ∅
         │   │   │       │       └── name: :bag
         │   │   │       ├── rest: ∅
         │   │   │       ├── rights: (length: 0)
@@ -271,6 +278,7 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
         │   │   │   └── @ RequiredKeywordParameterNode (location: (31,6)-(31,8))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :b
         │   │   │       └── name_loc: (31,6)-(31,8) = "b:"
         │   │   ├── keyword_rest: ∅
@@ -302,6 +310,7 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
         │   │   │   └── @ RequiredKeywordParameterNode (location: (35,6)-(35,8))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :b
         │   │   │       └── name_loc: (35,6)-(35,8) = "b:"
         │   │   ├── keyword_rest: ∅
@@ -328,6 +337,7 @@
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest:
         │   │   │   @ KeywordRestParameterNode (location: (38,6)-(38,9))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: :b
         │   │   │   ├── name_loc: (38,8)-(38,9) = "b"
         │   │   │   └── operator_loc: (38,6)-(38,8) = "**"
@@ -354,6 +364,7 @@
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest:
         │   │   │   @ KeywordRestParameterNode (location: (41,6)-(41,8))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (41,6)-(41,8) = "**"
@@ -397,10 +408,13 @@
         │   │   @ ParametersNode (location: (47,6)-(47,13))
         │   │   ├── requireds: (length: 3)
         │   │   │   ├── @ RequiredParameterNode (location: (47,6)-(47,7))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   └── name: :b
         │   │   │   ├── @ RequiredParameterNode (location: (47,9)-(47,10))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   └── name: :c
         │   │   │   └── @ RequiredParameterNode (location: (47,12)-(47,13))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :d
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -444,9 +458,11 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 2)
         │   │   │   ├── @ RequiredKeywordParameterNode (location: (53,6)-(53,8))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :b
         │   │   │   │   └── name_loc: (53,6)-(53,8) = "b:"
         │   │   │   └── @ OptionalKeywordParameterNode (location: (53,10)-(53,14))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :c
         │   │   │       ├── name_loc: (53,10)-(53,12) = "c:"
         │   │   │       └── value:
@@ -475,9 +491,11 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 2)
         │   │   │   ├── @ RequiredKeywordParameterNode (location: (56,6)-(56,8))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :b
         │   │   │   │   └── name_loc: (56,6)-(56,8) = "b:"
         │   │   │   └── @ OptionalKeywordParameterNode (location: (56,10)-(56,14))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :c
         │   │   │       ├── name_loc: (56,10)-(56,12) = "c:"
         │   │   │       └── value:
@@ -506,12 +524,14 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 2)
         │   │   │   ├── @ OptionalKeywordParameterNode (location: (59,6)-(60,3))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :b
         │   │   │   │   ├── name_loc: (59,6)-(59,8) = "b:"
         │   │   │   │   └── value:
         │   │   │   │       @ IntegerNode (location: (60,2)-(60,3))
         │   │   │   │       └── flags: decimal
         │   │   │   └── @ RequiredKeywordParameterNode (location: (60,5)-(60,7))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :c
         │   │   │       └── name_loc: (60,5)-(60,7) = "c:"
         │   │   ├── keyword_rest: ∅
@@ -540,6 +560,7 @@
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 2)
         │   │   │   ├── @ OptionalParameterNode (location: (65,6)-(65,11))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :b
         │   │   │   │   ├── name_loc: (65,6)-(65,7) = "b"
         │   │   │   │   ├── operator_loc: (65,8)-(65,9) = "="
@@ -547,6 +568,7 @@
         │   │   │   │       @ IntegerNode (location: (65,10)-(65,11))
         │   │   │   │       └── flags: decimal
         │   │   │   └── @ OptionalParameterNode (location: (65,13)-(65,18))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :c
         │   │   │       ├── name_loc: (65,13)-(65,14) = "c"
         │   │   │       ├── operator_loc: (65,15)-(65,16) = "="
@@ -589,9 +611,11 @@
         │   │   @ ParametersNode (location: (71,6)-(71,14))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (71,6)-(71,7))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :b
         │   │   ├── optionals: (length: 1)
         │   │   │   └── @ OptionalParameterNode (location: (71,9)-(71,14))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :c
         │   │   │       ├── name_loc: (71,9)-(71,10) = "c"
         │   │   │       ├── operator_loc: (71,11)-(71,12) = "="
@@ -620,6 +644,7 @@
         │   │   @ ParametersNode (location: (74,6)-(74,7))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (74,6)-(74,7))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :b
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -682,6 +707,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (79,6)-(79,8))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: :b
         │   │   │   ├── name_loc: (79,7)-(79,8) = "b"
         │   │   │   └── operator_loc: (79,6)-(79,7) = "*"
@@ -708,6 +734,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (82,6)-(82,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (82,6)-(82,7) = "*"
@@ -880,6 +907,7 @@
         │   │   @ ParametersNode (location: (106,8)-(106,11))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (106,8)-(106,11))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :bar
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -928,6 +956,7 @@
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
         │   │   │   @ RestParameterNode (location: (110,6)-(110,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
         │   │   │   └── operator_loc: (110,6)-(110,7) = "*"
@@ -1092,6 +1121,7 @@
         │   │   ├── keyword_rest: ∅
         │   │   └── block:
         │   │       @ BlockParameterNode (location: (119,6)-(119,8))
+        │   │       ├── flags: ∅
         │   │       ├── name: :b
         │   │       ├── name_loc: (119,7)-(119,8) = "b"
         │   │       └── operator_loc: (119,6)-(119,7) = "&"
@@ -1118,6 +1148,7 @@
         │   │   ├── keyword_rest: ∅
         │   │   └── block:
         │   │       @ BlockParameterNode (location: (122,6)-(122,7))
+        │   │       ├── flags: ∅
         │   │       ├── name: ∅
         │   │       ├── name_loc: ∅
         │   │       └── operator_loc: (122,6)-(122,7) = "&"
@@ -1360,6 +1391,7 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
         │   │   │   └── @ OptionalKeywordParameterNode (location: (142,8)-(142,19))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (142,8)-(142,10) = "a:"
         │   │   │       └── value:
@@ -1401,6 +1433,7 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
         │   │   │   └── @ OptionalKeywordParameterNode (location: (145,8)-(145,18))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (145,8)-(145,10) = "a:"
         │   │   │       └── value:
@@ -1440,6 +1473,7 @@
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
         │   │   │   └── @ OptionalKeywordParameterNode (location: (148,8)-(148,17))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (148,8)-(148,10) = "a:"
         │   │   │       └── value:
@@ -1476,6 +1510,7 @@
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 1)
         │   │   │   └── @ OptionalParameterNode (location: (151,8)-(151,20))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (151,8)-(151,9) = "a"
         │   │   │       ├── operator_loc: (151,10)-(151,11) = "="
@@ -1518,6 +1553,7 @@
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 1)
         │   │   │   └── @ OptionalParameterNode (location: (154,8)-(154,19))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (154,8)-(154,9) = "a"
         │   │   │       ├── operator_loc: (154,10)-(154,11) = "="
@@ -1558,6 +1594,7 @@
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 1)
         │   │   │   └── @ OptionalParameterNode (location: (157,8)-(157,18))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :a
         │   │   │       ├── name_loc: (157,8)-(157,9) = "a"
         │   │   │       ├── operator_loc: (157,10)-(157,11) = "="
@@ -1597,6 +1634,7 @@
         │   │   @ ParametersNode (location: (160,11)-(160,12))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (160,11)-(160,12))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :a
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -1655,128 +1693,100 @@
         │   ├── rparen_loc: (160,12)-(160,13) = ")"
         │   ├── equal_loc: ∅
         │   └── end_keyword_loc: (162,0)-(162,3) = "end"
-        ├── @ DefNode (location: (164,0)-(165,3))
+        ├── @ LocalVariableWriteNode (location: (164,0)-(164,7))
-        │   ├── name: :foo
-        │   ├── name_loc: (164,4)-(164,7) = "foo"
-        │   ├── receiver: ∅
-        │   ├── parameters:
-        │   │   @ ParametersNode (location: (164,8)-(164,20))
-        │   │   ├── requireds: (length: 4)
-        │   │   │   ├── @ RequiredParameterNode (location: (164,8)-(164,10))
-        │   │   │   │   └── name: :_a
-        │   │   │   ├── @ RequiredParameterNode (location: (164,12)-(164,14))
-        │   │   │   │   └── name: :_a
-        │   │   │   ├── @ RequiredParameterNode (location: (164,16)-(164,17))
-        │   │   │   │   └── name: :b
-        │   │   │   └── @ RequiredParameterNode (location: (164,19)-(164,20))
-        │   │   │       └── name: :c
-        │   │   ├── optionals: (length: 0)
-        │   │   ├── rest: ∅
-        │   │   ├── posts: (length: 0)
-        │   │   ├── keywords: (length: 0)
-        │   │   ├── keyword_rest: ∅
-        │   │   └── block: ∅
-        │   ├── body: ∅
-        │   ├── locals: [:_a, :b, :c]
-        │   ├── locals_body_index: 3
-        │   ├── def_keyword_loc: (164,0)-(164,3) = "def"
-        │   ├── operator_loc: ∅
-        │   ├── lparen_loc: (164,7)-(164,8) = "("
-        │   ├── rparen_loc: (164,20)-(164,21) = ")"
-        │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (165,0)-(165,3) = "end"
-        ├── @ LocalVariableWriteNode (location: (167,0)-(167,7))
         │   ├── name: :foo
         │   ├── depth: 0
-        │   ├── name_loc: (167,0)-(167,3) = "foo"
+        │   ├── name_loc: (164,0)-(164,3) = "foo"
         │   ├── value:
-        │   │   @ IntegerNode (location: (167,6)-(167,7))
+        │   │   @ IntegerNode (location: (164,6)-(164,7))
         │   │   └── flags: decimal
-        │   └── operator_loc: (167,4)-(167,5) = "="
+        │   └── operator_loc: (164,4)-(164,5) = "="
-        ├── @ DefNode (location: (168,0)-(168,16))
+        ├── @ DefNode (location: (165,0)-(165,16))
         │   ├── name: :bar
-        │   ├── name_loc: (168,8)-(168,11) = "bar"
+        │   ├── name_loc: (165,8)-(165,11) = "bar"
         │   ├── receiver:
-        │   │   @ LocalVariableReadNode (location: (168,4)-(168,7))
+        │   │   @ LocalVariableReadNode (location: (165,4)-(165,7))
         │   │   ├── name: :foo
         │   │   └── depth: 0
         │   ├── parameters: ∅
         │   ├── body: ∅
         │   ├── locals: []
         │   ├── locals_body_index: 0
-        │   ├── def_keyword_loc: (168,0)-(168,3) = "def"
+        │   ├── def_keyword_loc: (165,0)-(165,3) = "def"
-        │   ├── operator_loc: (168,7)-(168,8) = "."
+        │   ├── operator_loc: (165,7)-(165,8) = "."
         │   ├── lparen_loc: ∅
         │   ├── rparen_loc: ∅
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (168,13)-(168,16) = "end"
+        │   └── end_keyword_loc: (165,13)-(165,16) = "end"
-        ├── @ DefNode (location: (170,0)-(170,18))
+        ├── @ DefNode (location: (167,0)-(167,18))
         │   ├── name: :f
-        │   ├── name_loc: (170,4)-(170,5) = "f"
+        │   ├── name_loc: (167,4)-(167,5) = "f"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (170,6)-(170,7))
+        │   │   @ ParametersNode (location: (167,6)-(167,7))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest:
-        │   │   │   @ RestParameterNode (location: (170,6)-(170,7))
+        │   │   │   @ RestParameterNode (location: (167,6)-(167,7))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: ∅
         │   │   │   ├── name_loc: ∅
-        │   │   │   └── operator_loc: (170,6)-(170,7) = "*"
+        │   │   │   └── operator_loc: (167,6)-(167,7) = "*"
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest: ∅
         │   │   └── block: ∅
         │   ├── body:
-        │   │   @ StatementsNode (location: (170,10)-(170,13))
+        │   │   @ StatementsNode (location: (167,10)-(167,13))
         │   │   └── body: (length: 1)
-        │   │       └── @ ArrayNode (location: (170,10)-(170,13))
+        │   │       └── @ ArrayNode (location: (167,10)-(167,13))
         │   │           ├── flags: contains_splat
         │   │           ├── elements: (length: 1)
-        │   │           │   └── @ SplatNode (location: (170,11)-(170,12))
+        │   │           │   └── @ SplatNode (location: (167,11)-(167,12))
-        │   │           │       ├── operator_loc: (170,11)-(170,12) = "*"
+        │   │           │       ├── operator_loc: (167,11)-(167,12) = "*"
         │   │           │       └── expression: ∅
-        │   │           ├── opening_loc: (170,10)-(170,11) = "["
+        │   │           ├── opening_loc: (167,10)-(167,11) = "["
-        │   │           └── closing_loc: (170,12)-(170,13) = "]"
+        │   │           └── closing_loc: (167,12)-(167,13) = "]"
         │   ├── locals: [:*]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (170,0)-(170,3) = "def"
+        │   ├── def_keyword_loc: (167,0)-(167,3) = "def"
         │   ├── operator_loc: ∅
-        │   ├── lparen_loc: (170,5)-(170,6) = "("
+        │   ├── lparen_loc: (167,5)-(167,6) = "("
-        │   ├── rparen_loc: (170,7)-(170,8) = ")"
+        │   ├── rparen_loc: (167,7)-(167,8) = ")"
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (170,15)-(170,18) = "end"
+        │   └── end_keyword_loc: (167,15)-(167,18) = "end"
-        ├── @ DefNode (location: (172,0)-(172,15))
+        ├── @ DefNode (location: (169,0)-(169,15))
         │   ├── name: :f
-        │   ├── name_loc: (172,4)-(172,5) = "f"
+        │   ├── name_loc: (169,4)-(169,5) = "f"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (172,6)-(172,10))
+        │   │   @ ParametersNode (location: (169,6)-(169,10))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
-        │   │   │   └── @ OptionalKeywordParameterNode (location: (172,6)-(172,10))
+        │   │   │   └── @ OptionalKeywordParameterNode (location: (169,6)-(169,10))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :x
-        │   │   │       ├── name_loc: (172,6)-(172,8) = "x:"
+        │   │   │       ├── name_loc: (169,6)-(169,8) = "x:"
         │   │   │       └── value:
-        │   │   │           @ CallNode (location: (172,8)-(172,10))
+        │   │   │           @ CallNode (location: (169,8)-(169,10))
         │   │   │           ├── flags: ∅
         │   │   │           ├── receiver:
-        │   │   │           │   @ CallNode (location: (172,9)-(172,10))
+        │   │   │           │   @ CallNode (location: (169,9)-(169,10))
         │   │   │           │   ├── flags: variable_call, ignore_visibility
         │   │   │           │   ├── receiver: ∅
         │   │   │           │   ├── call_operator_loc: ∅
         │   │   │           │   ├── name: :a
-        │   │   │           │   ├── message_loc: (172,9)-(172,10) = "a"
+        │   │   │           │   ├── message_loc: (169,9)-(169,10) = "a"
         │   │   │           │   ├── opening_loc: ∅
         │   │   │           │   ├── arguments: ∅
         │   │   │           │   ├── closing_loc: ∅
         │   │   │           │   └── block: ∅
         │   │   │           ├── call_operator_loc: ∅
         │   │   │           ├── name: :-@
-        │   │   │           ├── message_loc: (172,8)-(172,9) = "-"
+        │   │   │           ├── message_loc: (169,8)-(169,9) = "-"
         │   │   │           ├── opening_loc: ∅
         │   │   │           ├── arguments: ∅
         │   │   │           ├── closing_loc: ∅
@@ -1786,43 +1796,44 @@
         │   ├── body: ∅
         │   ├── locals: [:x]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (172,0)-(172,3) = "def"
+        │   ├── def_keyword_loc: (169,0)-(169,3) = "def"
         │   ├── operator_loc: ∅
         │   ├── lparen_loc: ∅
         │   ├── rparen_loc: ∅
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (172,12)-(172,15) = "end"
+        │   └── end_keyword_loc: (169,12)-(169,15) = "end"
-        ├── @ DefNode (location: (174,0)-(174,15))
+        ├── @ DefNode (location: (171,0)-(171,15))
         │   ├── name: :f
-        │   ├── name_loc: (174,4)-(174,5) = "f"
+        │   ├── name_loc: (171,4)-(171,5) = "f"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (174,6)-(174,10))
+        │   │   @ ParametersNode (location: (171,6)-(171,10))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
-        │   │   │   └── @ OptionalKeywordParameterNode (location: (174,6)-(174,10))
+        │   │   │   └── @ OptionalKeywordParameterNode (location: (171,6)-(171,10))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :x
-        │   │   │       ├── name_loc: (174,6)-(174,8) = "x:"
+        │   │   │       ├── name_loc: (171,6)-(171,8) = "x:"
         │   │   │       └── value:
-        │   │   │           @ CallNode (location: (174,8)-(174,10))
+        │   │   │           @ CallNode (location: (171,8)-(171,10))
         │   │   │           ├── flags: ∅
         │   │   │           ├── receiver:
-        │   │   │           │   @ CallNode (location: (174,9)-(174,10))
+        │   │   │           │   @ CallNode (location: (171,9)-(171,10))
         │   │   │           │   ├── flags: variable_call, ignore_visibility
         │   │   │           │   ├── receiver: ∅
         │   │   │           │   ├── call_operator_loc: ∅
         │   │   │           │   ├── name: :a
-        │   │   │           │   ├── message_loc: (174,9)-(174,10) = "a"
+        │   │   │           │   ├── message_loc: (171,9)-(171,10) = "a"
         │   │   │           │   ├── opening_loc: ∅
         │   │   │           │   ├── arguments: ∅
         │   │   │           │   ├── closing_loc: ∅
         │   │   │           │   └── block: ∅
         │   │   │           ├── call_operator_loc: ∅
         │   │   │           ├── name: :+@
-        │   │   │           ├── message_loc: (174,8)-(174,9) = "+"
+        │   │   │           ├── message_loc: (171,8)-(171,9) = "+"
         │   │   │           ├── opening_loc: ∅
         │   │   │           ├── arguments: ∅
         │   │   │           ├── closing_loc: ∅
@@ -1832,43 +1843,44 @@
         │   ├── body: ∅
         │   ├── locals: [:x]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (174,0)-(174,3) = "def"
+        │   ├── def_keyword_loc: (171,0)-(171,3) = "def"
         │   ├── operator_loc: ∅
         │   ├── lparen_loc: ∅
         │   ├── rparen_loc: ∅
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (174,12)-(174,15) = "end"
+        │   └── end_keyword_loc: (171,12)-(171,15) = "end"
-        ├── @ DefNode (location: (176,0)-(176,15))
+        ├── @ DefNode (location: (173,0)-(173,15))
         │   ├── name: :f
-        │   ├── name_loc: (176,4)-(176,5) = "f"
+        │   ├── name_loc: (173,4)-(173,5) = "f"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (176,6)-(176,10))
+        │   │   @ ParametersNode (location: (173,6)-(173,10))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
-        │   │   │   └── @ OptionalKeywordParameterNode (location: (176,6)-(176,10))
+        │   │   │   └── @ OptionalKeywordParameterNode (location: (173,6)-(173,10))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :x
-        │   │   │       ├── name_loc: (176,6)-(176,8) = "x:"
+        │   │   │       ├── name_loc: (173,6)-(173,8) = "x:"
         │   │   │       └── value:
-        │   │   │           @ CallNode (location: (176,8)-(176,10))
+        │   │   │           @ CallNode (location: (173,8)-(173,10))
         │   │   │           ├── flags: ∅
         │   │   │           ├── receiver:
-        │   │   │           │   @ CallNode (location: (176,9)-(176,10))
+        │   │   │           │   @ CallNode (location: (173,9)-(173,10))
         │   │   │           │   ├── flags: variable_call, ignore_visibility
         │   │   │           │   ├── receiver: ∅
         │   │   │           │   ├── call_operator_loc: ∅
         │   │   │           │   ├── name: :a
-        │   │   │           │   ├── message_loc: (176,9)-(176,10) = "a"
+        │   │   │           │   ├── message_loc: (173,9)-(173,10) = "a"
         │   │   │           │   ├── opening_loc: ∅
         │   │   │           │   ├── arguments: ∅
         │   │   │           │   ├── closing_loc: ∅
         │   │   │           │   └── block: ∅
         │   │   │           ├── call_operator_loc: ∅
         │   │   │           ├── name: :!
-        │   │   │           ├── message_loc: (176,8)-(176,9) = "!"
+        │   │   │           ├── message_loc: (173,8)-(173,9) = "!"
         │   │   │           ├── opening_loc: ∅
         │   │   │           ├── arguments: ∅
         │   │   │           ├── closing_loc: ∅
@@ -1878,107 +1890,110 @@
         │   ├── body: ∅
         │   ├── locals: [:x]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (176,0)-(176,3) = "def"
+        │   ├── def_keyword_loc: (173,0)-(173,3) = "def"
         │   ├── operator_loc: ∅
         │   ├── lparen_loc: ∅
         │   ├── rparen_loc: ∅
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (176,12)-(176,15) = "end"
+        │   └── end_keyword_loc: (173,12)-(173,15) = "end"
-        ├── @ DefNode (location: (178,0)-(178,20))
+        ├── @ DefNode (location: (175,0)-(175,20))
         │   ├── name: :foo
-        │   ├── name_loc: (178,4)-(178,7) = "foo"
+        │   ├── name_loc: (175,4)-(175,7) = "foo"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (178,8)-(178,15))
+        │   │   @ ParametersNode (location: (175,8)-(175,15))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 1)
-        │   │   │   └── @ OptionalKeywordParameterNode (location: (178,8)-(178,15))
+        │   │   │   └── @ OptionalKeywordParameterNode (location: (175,8)-(175,15))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :x
-        │   │   │       ├── name_loc: (178,8)-(178,10) = "x:"
+        │   │   │       ├── name_loc: (175,8)-(175,10) = "x:"
         │   │   │       └── value:
-        │   │   │           @ StringNode (location: (178,10)-(178,15))
+        │   │   │           @ StringNode (location: (175,10)-(175,15))
         │   │   │           ├── flags: ∅
-        │   │   │           ├── opening_loc: (178,10)-(178,12) = "%("
+        │   │   │           ├── opening_loc: (175,10)-(175,12) = "%("
-        │   │   │           ├── content_loc: (178,12)-(178,14) = "xx"
+        │   │   │           ├── content_loc: (175,12)-(175,14) = "xx"
-        │   │   │           ├── closing_loc: (178,14)-(178,15) = ")"
+        │   │   │           ├── closing_loc: (175,14)-(175,15) = ")"
         │   │   │           └── unescaped: "xx"
         │   │   ├── keyword_rest: ∅
         │   │   └── block: ∅
         │   ├── body: ∅
         │   ├── locals: [:x]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (178,0)-(178,3) = "def"
+        │   ├── def_keyword_loc: (175,0)-(175,3) = "def"
         │   ├── operator_loc: ∅
         │   ├── lparen_loc: ∅
         │   ├── rparen_loc: ∅
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (178,17)-(178,20) = "end"
+        │   └── end_keyword_loc: (175,17)-(175,20) = "end"
-        ├── @ DefNode (location: (180,0)-(182,3))
+        ├── @ DefNode (location: (177,0)-(179,3))
         │   ├── name: :foo
-        │   ├── name_loc: (180,4)-(180,7) = "foo"
+        │   ├── name_loc: (177,4)-(177,7) = "foo"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (180,8)-(180,11))
+        │   │   @ ParametersNode (location: (177,8)-(177,11))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest:
-        │   │   │   @ ForwardingParameterNode (location: (180,8)-(180,11))
+        │   │   │   @ ForwardingParameterNode (location: (177,8)-(177,11))
         │   │   └── block: ∅
         │   ├── body:
-        │   │   @ StatementsNode (location: (181,2)-(181,7))
+        │   │   @ StatementsNode (location: (178,2)-(178,7))
         │   │   └── body: (length: 1)
-        │   │       └── @ CallNode (location: (181,2)-(181,7))
+        │   │       └── @ CallNode (location: (178,2)-(178,7))
         │   │           ├── flags: ignore_visibility
         │   │           ├── receiver: ∅
         │   │           ├── call_operator_loc: ∅
         │   │           ├── name: :bar
-        │   │           ├── message_loc: (181,2)-(181,5) = "bar"
+        │   │           ├── message_loc: (178,2)-(178,5) = "bar"
-        │   │           ├── opening_loc: (181,5)-(181,6) = "("
+        │   │           ├── opening_loc: (178,5)-(178,6) = "("
         │   │           ├── arguments: ∅
-        │   │           ├── closing_loc: (181,7)-(181,8) = ")"
+        │   │           ├── closing_loc: (178,7)-(178,8) = ")"
         │   │           └── block:
-        │   │               @ BlockArgumentNode (location: (181,6)-(181,7))
+        │   │               @ BlockArgumentNode (location: (178,6)-(178,7))
         │   │               ├── expression: ∅
-        │   │               └── operator_loc: (181,6)-(181,7) = "&"
+        │   │               └── operator_loc: (178,6)-(178,7) = "&"
         │   ├── locals: [:"..."]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (180,0)-(180,3) = "def"
+        │   ├── def_keyword_loc: (177,0)-(177,3) = "def"
         │   ├── operator_loc: ∅
-        │   ├── lparen_loc: (180,7)-(180,8) = "("
+        │   ├── lparen_loc: (177,7)-(177,8) = "("
-        │   ├── rparen_loc: (180,11)-(180,12) = ")"
+        │   ├── rparen_loc: (177,11)-(177,12) = ")"
         │   ├── equal_loc: ∅
-        │   └── end_keyword_loc: (182,0)-(182,3) = "end"
+        │   └── end_keyword_loc: (179,0)-(179,3) = "end"
-        ├── @ DefNode (location: (184,0)-(184,42))
+        ├── @ DefNode (location: (181,0)-(181,42))
         │   ├── name: :foo
-        │   ├── name_loc: (184,4)-(184,7) = "foo"
+        │   ├── name_loc: (181,4)-(181,7) = "foo"
         │   ├── receiver: ∅
         │   ├── parameters:
-        │   │   @ ParametersNode (location: (184,8)-(184,37))
+        │   │   @ ParametersNode (location: (181,8)-(181,37))
         │   │   ├── requireds: (length: 0)
         │   │   ├── optionals: (length: 1)
-        │   │   │   └── @ OptionalParameterNode (location: (184,8)-(184,37))
+        │   │   │   └── @ OptionalParameterNode (location: (181,8)-(181,37))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :bar
-        │   │   │       ├── name_loc: (184,8)-(184,11) = "bar"
+        │   │   │       ├── name_loc: (181,8)-(181,11) = "bar"
-        │   │   │       ├── operator_loc: (184,12)-(184,13) = "="
+        │   │   │       ├── operator_loc: (181,12)-(181,13) = "="
         │   │   │       └── value:
-        │   │   │           @ ParenthesesNode (location: (184,14)-(184,37))
+        │   │   │           @ ParenthesesNode (location: (181,14)-(181,37))
         │   │   │           ├── body:
-        │   │   │           │   @ StatementsNode (location: (184,15)-(184,36))
+        │   │   │           │   @ StatementsNode (location: (181,15)-(181,36))
         │   │   │           │   └── body: (length: 2)
-        │   │   │           │       ├── @ DefNode (location: (184,15)-(184,33))
+        │   │   │           │       ├── @ DefNode (location: (181,15)-(181,33))
         │   │   │           │       │   ├── name: :baz
-        │   │   │           │       │   ├── name_loc: (184,19)-(184,22) = "baz"
+        │   │   │           │       │   ├── name_loc: (181,19)-(181,22) = "baz"
         │   │   │           │       │   ├── receiver: ∅
         │   │   │           │       │   ├── parameters:
-        │   │   │           │       │   │   @ ParametersNode (location: (184,23)-(184,26))
+        │   │   │           │       │   │   @ ParametersNode (location: (181,23)-(181,26))
         │   │   │           │       │   │   ├── requireds: (length: 1)
-        │   │   │           │       │   │   │   └── @ RequiredParameterNode (location: (184,23)-(184,26))
+        │   │   │           │       │   │   │   └── @ RequiredParameterNode (location: (181,23)-(181,26))
+        │   │   │           │       │   │   │       ├── flags: ∅
         │   │   │           │       │   │   │       └── name: :bar
         │   │   │           │       │   │   ├── optionals: (length: 0)
         │   │   │           │       │   │   ├── rest: ∅
@@ -1987,70 +2002,71 @@
         │   │   │           │       │   │   ├── keyword_rest: ∅
         │   │   │           │       │   │   └── block: ∅
         │   │   │           │       │   ├── body:
-        │   │   │           │       │   │   @ StatementsNode (location: (184,30)-(184,33))
+        │   │   │           │       │   │   @ StatementsNode (location: (181,30)-(181,33))
         │   │   │           │       │   │   └── body: (length: 1)
-        │   │   │           │       │   │       └── @ LocalVariableReadNode (location: (184,30)-(184,33))
+        │   │   │           │       │   │       └── @ LocalVariableReadNode (location: (181,30)-(181,33))
         │   │   │           │       │   │           ├── name: :bar
         │   │   │           │       │   │           └── depth: 0
         │   │   │           │       │   ├── locals: [:bar]
         │   │   │           │       │   ├── locals_body_index: 1
-        │   │   │           │       │   ├── def_keyword_loc: (184,15)-(184,18) = "def"
+        │   │   │           │       │   ├── def_keyword_loc: (181,15)-(181,18) = "def"
         │   │   │           │       │   ├── operator_loc: ∅
-        │   │   │           │       │   ├── lparen_loc: (184,22)-(184,23) = "("
+        │   │   │           │       │   ├── lparen_loc: (181,22)-(181,23) = "("
-        │   │   │           │       │   ├── rparen_loc: (184,26)-(184,27) = ")"
+        │   │   │           │       │   ├── rparen_loc: (181,26)-(181,27) = ")"
-        │   │   │           │       │   ├── equal_loc: (184,28)-(184,29) = "="
+        │   │   │           │       │   ├── equal_loc: (181,28)-(181,29) = "="
         │   │   │           │       │   └── end_keyword_loc: ∅
-        │   │   │           │       └── @ IntegerNode (location: (184,35)-(184,36))
+        │   │   │           │       └── @ IntegerNode (location: (181,35)-(181,36))
         │   │   │           │           └── flags: decimal
-        │   │   │           ├── opening_loc: (184,14)-(184,15) = "("
+        │   │   │           ├── opening_loc: (181,14)-(181,15) = "("
-        │   │   │           └── closing_loc: (184,36)-(184,37) = ")"
+        │   │   │           └── closing_loc: (181,36)-(181,37) = ")"
         │   │   ├── rest: ∅
         │   │   ├── posts: (length: 0)
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest: ∅
         │   │   └── block: ∅
         │   ├── body:
-        │   │   @ StatementsNode (location: (184,41)-(184,42))
+        │   │   @ StatementsNode (location: (181,41)-(181,42))
         │   │   └── body: (length: 1)
-        │   │       └── @ IntegerNode (location: (184,41)-(184,42))
+        │   │       └── @ IntegerNode (location: (181,41)-(181,42))
         │   │           └── flags: decimal
         │   ├── locals: [:bar]
         │   ├── locals_body_index: 1
-        │   ├── def_keyword_loc: (184,0)-(184,3) = "def"
+        │   ├── def_keyword_loc: (181,0)-(181,3) = "def"
         │   ├── operator_loc: ∅
-        │   ├── lparen_loc: (184,7)-(184,8) = "("
+        │   ├── lparen_loc: (181,7)-(181,8) = "("
-        │   ├── rparen_loc: (184,37)-(184,38) = ")"
+        │   ├── rparen_loc: (181,37)-(181,38) = ")"
-        │   ├── equal_loc: (184,39)-(184,40) = "="
+        │   ├── equal_loc: (181,39)-(181,40) = "="
         │   └── end_keyword_loc: ∅
-        └── @ DefNode (location: (186,0)-(186,37))
+        └── @ DefNode (location: (183,0)-(183,37))
             ├── name: :foo
-            ├── name_loc: (186,21)-(186,24) = "foo"
+            ├── name_loc: (183,21)-(183,24) = "foo"
             ├── receiver:
-            │   @ ParenthesesNode (location: (186,4)-(186,20))
+            │   @ ParenthesesNode (location: (183,4)-(183,20))
             │   ├── body:
-            │   │   @ ClassNode (location: (186,5)-(186,19))
+            │   │   @ ClassNode (location: (183,5)-(183,19))
             │   │   ├── locals: []
-            │   │   ├── class_keyword_loc: (186,5)-(186,10) = "class"
+            │   │   ├── class_keyword_loc: (183,5)-(183,10) = "class"
             │   │   ├── constant_path:
-            │   │   │   @ ConstantReadNode (location: (186,11)-(186,14))
+            │   │   │   @ ConstantReadNode (location: (183,11)-(183,14))
             │   │   │   └── name: :Foo
             │   │   ├── inheritance_operator_loc: ∅
             │   │   ├── superclass: ∅
             │   │   ├── body: ∅
-            │   │   ├── end_keyword_loc: (186,16)-(186,19) = "end"
+            │   │   ├── end_keyword_loc: (183,16)-(183,19) = "end"
             │   │   └── name: :Foo
-            │   ├── opening_loc: (186,4)-(186,5) = "("
+            │   ├── opening_loc: (183,4)-(183,5) = "("
-            │   └── closing_loc: (186,19)-(186,20) = ")"
+            │   └── closing_loc: (183,19)-(183,20) = ")"
             ├── parameters:
-            │   @ ParametersNode (location: (186,25)-(186,32))
+            │   @ ParametersNode (location: (183,25)-(183,32))
             │   ├── requireds: (length: 0)
             │   ├── optionals: (length: 1)
-            │   │   └── @ OptionalParameterNode (location: (186,25)-(186,32))
+            │   │   └── @ OptionalParameterNode (location: (183,25)-(183,32))
+            │   │       ├── flags: ∅
             │   │       ├── name: :bar
-            │   │       ├── name_loc: (186,25)-(186,28) = "bar"
+            │   │       ├── name_loc: (183,25)-(183,28) = "bar"
-            │   │       ├── operator_loc: (186,29)-(186,30) = "="
+            │   │       ├── operator_loc: (183,29)-(183,30) = "="
             │   │       └── value:
-            │   │           @ IntegerNode (location: (186,31)-(186,32))
+            │   │           @ IntegerNode (location: (183,31)-(183,32))
             │   │           └── flags: decimal
             │   ├── rest: ∅
             │   ├── posts: (length: 0)
@@ -2058,15 +2074,15 @@
             │   ├── keyword_rest: ∅
             │   └── block: ∅
             ├── body:
-            │   @ StatementsNode (location: (186,36)-(186,37))
+            │   @ StatementsNode (location: (183,36)-(183,37))
             │   └── body: (length: 1)
-            │       └── @ IntegerNode (location: (186,36)-(186,37))
+            │       └── @ IntegerNode (location: (183,36)-(183,37))
             │           └── flags: decimal
             ├── locals: [:bar]
             ├── locals_body_index: 1
-            ├── def_keyword_loc: (186,0)-(186,3) = "def"
+            ├── def_keyword_loc: (183,0)-(183,3) = "def"
-            ├── operator_loc: (186,20)-(186,21) = "."
+            ├── operator_loc: (183,20)-(183,21) = "."
-            ├── lparen_loc: (186,24)-(186,25) = "("
+            ├── lparen_loc: (183,24)-(183,25) = "("
-            ├── rparen_loc: (186,32)-(186,33) = ")"
+            ├── rparen_loc: (183,32)-(183,33) = ")"
-            ├── equal_loc: (186,34)-(186,35) = "="
+            ├── equal_loc: (183,34)-(183,35) = "="
             └── end_keyword_loc: ∅

test/prism/snapshots/non_alphanumeric_methods.txt

@@ -135,6 +135,7 @@
         │   │   ├── keywords: (length: 0)
         │   │   ├── keyword_rest:
         │   │   │   @ KeywordRestParameterNode (location: (27,6)-(27,9))
+        │   │   │   ├── flags: ∅
         │   │   │   ├── name: :b
         │   │   │   ├── name_loc: (27,8)-(27,9) = "b"
         │   │   │   └── operator_loc: (27,6)-(27,8) = "**"
@@ -170,6 +171,7 @@
         │   │   @ ParametersNode (location: (33,6)-(33,7))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (33,6)-(33,7))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :b
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅

test/prism/snapshots/procs.txt

@@ -15,6 +15,7 @@
         │   │   │   @ ParametersNode (location: (1,4)-(1,5))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :a
         │   │   │   ├── optionals: (length: 0)
         │   │   │   ├── rest: ∅
@@ -24,10 +25,13 @@
         │   │   │   └── block: ∅
         │   │   ├── locals: (length: 3)
         │   │   │   ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   └── name: :b
         │   │   │   ├── @ BlockLocalVariableNode (location: (1,10)-(1,11))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   └── name: :c
         │   │   │   └── @ BlockLocalVariableNode (location: (1,13)-(1,14))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :d
         │   │   ├── opening_loc: (1,3)-(1,4) = "("
         │   │   └── closing_loc: (1,14)-(1,15) = ")"
@@ -138,9 +142,11 @@
         │   │   │   @ ParametersNode (location: (17,3)-(17,23))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (17,3)-(17,4))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :a
         │   │   │   ├── optionals: (length: 1)
         │   │   │   │   └── @ OptionalParameterNode (location: (17,6)-(17,11))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :b
         │   │   │   │       ├── name_loc: (17,6)-(17,7) = "b"
         │   │   │   │       ├── operator_loc: (17,8)-(17,9) = "="
@@ -151,14 +157,17 @@
         │   │   │   ├── posts: (length: 0)
         │   │   │   ├── keywords: (length: 2)
         │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (17,13)-(17,15))
+        │   │   │   │   │   ├── flags: ∅
         │   │   │   │   │   ├── name: :c
         │   │   │   │   │   └── name_loc: (17,13)-(17,15) = "c:"
         │   │   │   │   └── @ RequiredKeywordParameterNode (location: (17,17)-(17,19))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :d
         │   │   │   │       └── name_loc: (17,17)-(17,19) = "d:"
         │   │   │   ├── keyword_rest: ∅
         │   │   │   └── block:
         │   │   │       @ BlockParameterNode (location: (17,21)-(17,23))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :e
         │   │   │       ├── name_loc: (17,22)-(17,23) = "e"
         │   │   │       └── operator_loc: (17,21)-(17,22) = "&"
@@ -183,9 +192,11 @@
         │   │   │   @ ParametersNode (location: (19,4)-(19,33))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (19,4)-(19,5))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :a
         │   │   │   ├── optionals: (length: 1)
         │   │   │   │   └── @ OptionalParameterNode (location: (19,7)-(19,12))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :b
         │   │   │   │       ├── name_loc: (19,7)-(19,8) = "b"
         │   │   │   │       ├── operator_loc: (19,9)-(19,10) = "="
@@ -194,24 +205,29 @@
         │   │   │   │           └── flags: decimal
         │   │   │   ├── rest:
         │   │   │   │   @ RestParameterNode (location: (19,14)-(19,16))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :c
         │   │   │   │   ├── name_loc: (19,15)-(19,16) = "c"
         │   │   │   │   └── operator_loc: (19,14)-(19,15) = "*"
         │   │   │   ├── posts: (length: 0)
         │   │   │   ├── keywords: (length: 2)
         │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (19,18)-(19,20))
+        │   │   │   │   │   ├── flags: ∅
         │   │   │   │   │   ├── name: :d
         │   │   │   │   │   └── name_loc: (19,18)-(19,20) = "d:"
         │   │   │   │   └── @ RequiredKeywordParameterNode (location: (19,22)-(19,24))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :e
         │   │   │   │       └── name_loc: (19,22)-(19,24) = "e:"
         │   │   │   ├── keyword_rest:
         │   │   │   │   @ KeywordRestParameterNode (location: (19,26)-(19,29))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :f
         │   │   │   │   ├── name_loc: (19,28)-(19,29) = "f"
         │   │   │   │   └── operator_loc: (19,26)-(19,28) = "**"
         │   │   │   └── block:
         │   │   │       @ BlockParameterNode (location: (19,31)-(19,33))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :g
         │   │   │       ├── name_loc: (19,32)-(19,33) = "g"
         │   │   │       └── operator_loc: (19,31)-(19,32) = "&"
@@ -236,9 +252,11 @@
         │   │   │   @ ParametersNode (location: (21,4)-(21,33))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (21,4)-(21,5))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :a
         │   │   │   ├── optionals: (length: 1)
         │   │   │   │   └── @ OptionalParameterNode (location: (21,7)-(21,12))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :b
         │   │   │   │       ├── name_loc: (21,7)-(21,8) = "b"
         │   │   │   │       ├── operator_loc: (21,9)-(21,10) = "="
@@ -247,24 +265,29 @@
         │   │   │   │           └── flags: decimal
         │   │   │   ├── rest:
         │   │   │   │   @ RestParameterNode (location: (21,14)-(21,16))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :c
         │   │   │   │   ├── name_loc: (21,15)-(21,16) = "c"
         │   │   │   │   └── operator_loc: (21,14)-(21,15) = "*"
         │   │   │   ├── posts: (length: 0)
         │   │   │   ├── keywords: (length: 2)
         │   │   │   │   ├── @ RequiredKeywordParameterNode (location: (21,18)-(21,20))
+        │   │   │   │   │   ├── flags: ∅
         │   │   │   │   │   ├── name: :d
         │   │   │   │   │   └── name_loc: (21,18)-(21,20) = "d:"
         │   │   │   │   └── @ RequiredKeywordParameterNode (location: (21,22)-(21,24))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       ├── name: :e
         │   │   │   │       └── name_loc: (21,22)-(21,24) = "e:"
         │   │   │   ├── keyword_rest:
         │   │   │   │   @ KeywordRestParameterNode (location: (21,26)-(21,29))
+        │   │   │   │   ├── flags: ∅
         │   │   │   │   ├── name: :f
         │   │   │   │   ├── name_loc: (21,28)-(21,29) = "f"
         │   │   │   │   └── operator_loc: (21,26)-(21,28) = "**"
         │   │   │   └── block:
         │   │   │       @ BlockParameterNode (location: (21,31)-(21,33))
+        │   │   │       ├── flags: ∅
         │   │   │       ├── name: :g
         │   │   │       ├── name_loc: (21,32)-(21,33) = "g"
         │   │   │       └── operator_loc: (21,31)-(21,32) = "&"
@@ -289,6 +312,7 @@
         │   │   │   @ ParametersNode (location: (25,4)-(25,5))
         │   │   │   ├── requireds: (length: 1)
         │   │   │   │   └── @ RequiredParameterNode (location: (25,4)-(25,5))
+        │   │   │   │       ├── flags: ∅
         │   │   │   │       └── name: :a
         │   │   │   ├── optionals: (length: 0)
         │   │   │   ├── rest: ∅
@@ -314,6 +338,7 @@
         │               │   │   @ ParametersNode (location: (25,12)-(25,13))
         │               │   │   ├── requireds: (length: 1)
         │               │   │   │   └── @ RequiredParameterNode (location: (25,12)-(25,13))
+        │               │   │   │       ├── flags: ∅
         │               │   │   │       └── name: :b
         │               │   │   ├── optionals: (length: 0)
         │               │   │   ├── rest: ∅
@@ -360,8 +385,10 @@
             │   │   │   └── @ MultiTargetNode (location: (27,4)-(27,10))
             │   │   │       ├── lefts: (length: 2)
             │   │   │       │   ├── @ RequiredParameterNode (location: (27,5)-(27,6))
+            │   │   │       │   │   ├── flags: ∅
             │   │   │       │   │   └── name: :a
             │   │   │       │   └── @ RequiredParameterNode (location: (27,8)-(27,9))
+            │   │   │       │       ├── flags: ∅
             │   │   │       │       └── name: :b
             │   │   │       ├── rest: ∅
             │   │   │       ├── rights: (length: 0)
@@ -370,6 +397,7 @@
             │   │   ├── optionals: (length: 0)
             │   │   ├── rest:
             │   │   │   @ RestParameterNode (location: (27,12)-(27,14))
+            │   │   │   ├── flags: ∅
             │   │   │   ├── name: :c
             │   │   │   ├── name_loc: (27,13)-(27,14) = "c"
             │   │   │   └── operator_loc: (27,12)-(27,13) = "*"

test/prism/snapshots/repeat_parameters.txt

@@ -0,0 +1,482 @@
+@ ProgramNode (location: (1,0)-(38,3))
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (1,0)-(38,3))
+    └── body: (length: 13)
+        ├── @ DefNode (location: (1,0)-(2,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (1,4)-(1,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (1,8)-(1,12))
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ RequiredParameterNode (location: (1,8)-(1,9))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :a
+        │   │   │   └── @ RequiredParameterNode (location: (1,11)-(1,12))
+        │   │   │       ├── flags: ∅
+        │   │   │       └── name: :_
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :_]
+        │   ├── locals_body_index: 2
+        │   ├── def_keyword_loc: (1,0)-(1,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (1,7)-(1,8) = "("
+        │   ├── rparen_loc: (1,12)-(1,13) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (2,0)-(2,3) = "end"
+        ├── @ DefNode (location: (4,0)-(5,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (4,4)-(4,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (4,8)-(4,15))
+        │   │   ├── requireds: (length: 3)
+        │   │   │   ├── @ RequiredParameterNode (location: (4,8)-(4,9))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :a
+        │   │   │   ├── @ RequiredParameterNode (location: (4,11)-(4,12))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :_
+        │   │   │   └── @ RequiredParameterNode (location: (4,14)-(4,15))
+        │   │   │       ├── flags: repeated_parameter
+        │   │   │       └── name: :_
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :_]
+        │   ├── locals_body_index: 2
+        │   ├── def_keyword_loc: (4,0)-(4,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (4,7)-(4,8) = "("
+        │   ├── rparen_loc: (4,15)-(4,16) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (5,0)-(5,3) = "end"
+        ├── @ DefNode (location: (7,0)-(8,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (7,4)-(7,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (7,8)-(7,19))
+        │   │   ├── requireds: (length: 4)
+        │   │   │   ├── @ RequiredParameterNode (location: (7,8)-(7,9))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :a
+        │   │   │   ├── @ RequiredParameterNode (location: (7,11)-(7,12))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :_
+        │   │   │   ├── @ RequiredParameterNode (location: (7,14)-(7,15))
+        │   │   │   │   ├── flags: repeated_parameter
+        │   │   │   │   └── name: :_
+        │   │   │   └── @ RequiredParameterNode (location: (7,17)-(7,19))
+        │   │   │       ├── flags: ∅
+        │   │   │       └── name: :_b
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :_, :_b]
+        │   ├── locals_body_index: 3
+        │   ├── def_keyword_loc: (7,0)-(7,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (7,7)-(7,8) = "("
+        │   ├── rparen_loc: (7,19)-(7,20) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (8,0)-(8,3) = "end"
+        ├── @ DefNode (location: (10,0)-(11,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (10,4)-(10,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (10,8)-(10,23))
+        │   │   ├── requireds: (length: 5)
+        │   │   │   ├── @ RequiredParameterNode (location: (10,8)-(10,9))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :a
+        │   │   │   ├── @ RequiredParameterNode (location: (10,11)-(10,12))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :_
+        │   │   │   ├── @ RequiredParameterNode (location: (10,14)-(10,15))
+        │   │   │   │   ├── flags: repeated_parameter
+        │   │   │   │   └── name: :_
+        │   │   │   ├── @ RequiredParameterNode (location: (10,17)-(10,19))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :_b
+        │   │   │   └── @ RequiredParameterNode (location: (10,21)-(10,23))
+        │   │   │       ├── flags: repeated_parameter
+        │   │   │       └── name: :_b
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :_, :_b]
+        │   ├── locals_body_index: 3
+        │   ├── def_keyword_loc: (10,0)-(10,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (10,7)-(10,8) = "("
+        │   ├── rparen_loc: (10,23)-(10,24) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
+        ├── @ DefNode (location: (13,0)-(14,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (13,4)-(13,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (13,8)-(13,35))
+        │   │   ├── requireds: (length: 3)
+        │   │   │   ├── @ RequiredParameterNode (location: (13,8)-(13,9))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :a
+        │   │   │   ├── @ MultiTargetNode (location: (13,11)-(13,22))
+        │   │   │   │   ├── lefts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (13,12)-(13,13))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :b
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ SplatNode (location: (13,15)-(13,18))
+        │   │   │   │   │   ├── operator_loc: (13,15)-(13,16) = "*"
+        │   │   │   │   │   └── expression:
+        │   │   │   │   │       @ RequiredParameterNode (location: (13,16)-(13,18))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :_c
+        │   │   │   │   ├── rights: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (13,20)-(13,21))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :d
+        │   │   │   │   ├── lparen_loc: (13,11)-(13,12) = "("
+        │   │   │   │   └── rparen_loc: (13,21)-(13,22) = ")"
+        │   │   │   └── @ MultiTargetNode (location: (13,24)-(13,35))
+        │   │   │       ├── lefts: (length: 1)
+        │   │   │       │   └── @ RequiredParameterNode (location: (13,25)-(13,26))
+        │   │   │       │       ├── flags: ∅
+        │   │   │       │       └── name: :e
+        │   │   │       ├── rest:
+        │   │   │       │   @ SplatNode (location: (13,28)-(13,31))
+        │   │   │       │   ├── operator_loc: (13,28)-(13,29) = "*"
+        │   │   │       │   └── expression:
+        │   │   │       │       @ RequiredParameterNode (location: (13,29)-(13,31))
+        │   │   │       │       ├── flags: repeated_parameter
+        │   │   │       │       └── name: :_c
+        │   │   │       ├── rights: (length: 1)
+        │   │   │       │   └── @ RequiredParameterNode (location: (13,33)-(13,34))
+        │   │   │       │       ├── flags: ∅
+        │   │   │       │       └── name: :f
+        │   │   │       ├── lparen_loc: (13,24)-(13,25) = "("
+        │   │   │       └── rparen_loc: (13,34)-(13,35) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :b, :_c, :d, :e, :f]
+        │   ├── locals_body_index: 6
+        │   ├── def_keyword_loc: (13,0)-(13,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (13,7)-(13,8) = "("
+        │   ├── rparen_loc: (13,35)-(13,36) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (14,0)-(14,3) = "end"
+        ├── @ DefNode (location: (16,0)-(17,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (16,4)-(16,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (16,8)-(16,20))
+        │   │   ├── requireds: (length: 4)
+        │   │   │   ├── @ RequiredParameterNode (location: (16,8)-(16,10))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :_a
+        │   │   │   ├── @ RequiredParameterNode (location: (16,12)-(16,14))
+        │   │   │   │   ├── flags: repeated_parameter
+        │   │   │   │   └── name: :_a
+        │   │   │   ├── @ RequiredParameterNode (location: (16,16)-(16,17))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   └── name: :b
+        │   │   │   └── @ RequiredParameterNode (location: (16,19)-(16,20))
+        │   │   │       ├── flags: ∅
+        │   │   │       └── name: :c
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_a, :b, :c]
+        │   ├── locals_body_index: 3
+        │   ├── def_keyword_loc: (16,0)-(16,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (16,7)-(16,8) = "("
+        │   ├── rparen_loc: (16,20)-(16,21) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (17,0)-(17,3) = "end"
+        ├── @ DefNode (location: (19,0)-(20,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (19,4)-(19,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (19,8)-(19,32))
+        │   │   ├── requireds: (length: 2)
+        │   │   │   ├── @ MultiTargetNode (location: (19,8)-(19,19))
+        │   │   │   │   ├── lefts: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (19,9)-(19,10))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :a
+        │   │   │   │   ├── rest:
+        │   │   │   │   │   @ SplatNode (location: (19,12)-(19,15))
+        │   │   │   │   │   ├── operator_loc: (19,12)-(19,13) = "*"
+        │   │   │   │   │   └── expression:
+        │   │   │   │   │       @ RequiredParameterNode (location: (19,13)-(19,15))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :_b
+        │   │   │   │   ├── rights: (length: 1)
+        │   │   │   │   │   └── @ RequiredParameterNode (location: (19,17)-(19,18))
+        │   │   │   │   │       ├── flags: ∅
+        │   │   │   │   │       └── name: :c
+        │   │   │   │   ├── lparen_loc: (19,8)-(19,9) = "("
+        │   │   │   │   └── rparen_loc: (19,18)-(19,19) = ")"
+        │   │   │   └── @ MultiTargetNode (location: (19,21)-(19,32))
+        │   │   │       ├── lefts: (length: 1)
+        │   │   │       │   └── @ RequiredParameterNode (location: (19,22)-(19,23))
+        │   │   │       │       ├── flags: ∅
+        │   │   │       │       └── name: :d
+        │   │   │       ├── rest:
+        │   │   │       │   @ SplatNode (location: (19,25)-(19,28))
+        │   │   │       │   ├── operator_loc: (19,25)-(19,26) = "*"
+        │   │   │       │   └── expression:
+        │   │   │       │       @ RequiredParameterNode (location: (19,26)-(19,28))
+        │   │   │       │       ├── flags: repeated_parameter
+        │   │   │       │       └── name: :_b
+        │   │   │       ├── rights: (length: 1)
+        │   │   │       │   └── @ RequiredParameterNode (location: (19,30)-(19,31))
+        │   │   │       │       ├── flags: ∅
+        │   │   │       │       └── name: :e
+        │   │   │       ├── lparen_loc: (19,21)-(19,22) = "("
+        │   │   │       └── rparen_loc: (19,31)-(19,32) = ")"
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:a, :_b, :c, :d, :e]
+        │   ├── locals_body_index: 5
+        │   ├── def_keyword_loc: (19,0)-(19,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (19,7)-(19,8) = "("
+        │   ├── rparen_loc: (19,32)-(19,33) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (20,0)-(20,3) = "end"
+        ├── @ DefNode (location: (22,0)-(23,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (22,4)-(22,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (22,8)-(22,22))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 2)
+        │   │   │   ├── @ OptionalParameterNode (location: (22,8)-(22,14))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   ├── name: :_a
+        │   │   │   │   ├── name_loc: (22,8)-(22,10) = "_a"
+        │   │   │   │   ├── operator_loc: (22,11)-(22,12) = "="
+        │   │   │   │   └── value:
+        │   │   │   │       @ IntegerNode (location: (22,13)-(22,14))
+        │   │   │   │       └── flags: decimal
+        │   │   │   └── @ OptionalParameterNode (location: (22,16)-(22,22))
+        │   │   │       ├── flags: repeated_parameter
+        │   │   │       ├── name: :_a
+        │   │   │       ├── name_loc: (22,16)-(22,18) = "_a"
+        │   │   │       ├── operator_loc: (22,19)-(22,20) = "="
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (22,21)-(22,22))
+        │   │   │           └── flags: decimal
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_a]
+        │   ├── locals_body_index: 1
+        │   ├── def_keyword_loc: (22,0)-(22,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (22,7)-(22,8) = "("
+        │   ├── rparen_loc: (22,22)-(22,23) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (23,0)-(23,3) = "end"
+        ├── @ DefNode (location: (25,0)-(26,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (25,4)-(25,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (25,8)-(25,16))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ RequiredKeywordParameterNode (location: (25,8)-(25,11))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   ├── name: :_a
+        │   │   │   │   └── name_loc: (25,8)-(25,11) = "_a:"
+        │   │   │   └── @ RequiredKeywordParameterNode (location: (25,13)-(25,16))
+        │   │   │       ├── flags: repeated_parameter
+        │   │   │       ├── name: :_a
+        │   │   │       └── name_loc: (25,13)-(25,16) = "_a:"
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_a]
+        │   ├── locals_body_index: 1
+        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (25,7)-(25,8) = "("
+        │   ├── rparen_loc: (25,16)-(25,17) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (26,0)-(26,3) = "end"
+        ├── @ DefNode (location: (28,0)-(29,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (28,4)-(28,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (28,8)-(28,20))
+        │   │   ├── requireds: (length: 0)
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 2)
+        │   │   │   ├── @ OptionalKeywordParameterNode (location: (28,8)-(28,13))
+        │   │   │   │   ├── flags: ∅
+        │   │   │   │   ├── name: :_a
+        │   │   │   │   ├── name_loc: (28,8)-(28,11) = "_a:"
+        │   │   │   │   └── value:
+        │   │   │   │       @ IntegerNode (location: (28,12)-(28,13))
+        │   │   │   │       └── flags: decimal
+        │   │   │   └── @ OptionalKeywordParameterNode (location: (28,15)-(28,20))
+        │   │   │       ├── flags: repeated_parameter
+        │   │   │       ├── name: :_a
+        │   │   │       ├── name_loc: (28,15)-(28,18) = "_a:"
+        │   │   │       └── value:
+        │   │   │           @ IntegerNode (location: (28,19)-(28,20))
+        │   │   │           └── flags: decimal
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_a]
+        │   ├── locals_body_index: 1
+        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (28,7)-(28,8) = "("
+        │   ├── rparen_loc: (28,20)-(28,21) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (29,0)-(29,3) = "end"
+        ├── @ DefNode (location: (31,0)-(32,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (31,4)-(31,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (31,8)-(31,16))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (31,8)-(31,10))
+        │   │   │       ├── flags: ∅
+        │   │   │       └── name: :_a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest:
+        │   │   │   @ KeywordRestParameterNode (location: (31,12)-(31,16))
+        │   │   │   ├── flags: repeated_parameter
+        │   │   │   ├── name: :_a
+        │   │   │   ├── name_loc: (31,14)-(31,16) = "_a"
+        │   │   │   └── operator_loc: (31,12)-(31,14) = "**"
+        │   │   └── block: ∅
+        │   ├── body: ∅
+        │   ├── locals: [:_a]
+        │   ├── locals_body_index: 1
+        │   ├── def_keyword_loc: (31,0)-(31,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (31,7)-(31,8) = "("
+        │   ├── rparen_loc: (31,16)-(31,17) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (32,0)-(32,3) = "end"
+        ├── @ DefNode (location: (34,0)-(35,3))
+        │   ├── name: :foo
+        │   ├── name_loc: (34,4)-(34,7) = "foo"
+        │   ├── receiver: ∅
+        │   ├── parameters:
+        │   │   @ ParametersNode (location: (34,8)-(34,15))
+        │   │   ├── requireds: (length: 1)
+        │   │   │   └── @ RequiredParameterNode (location: (34,8)-(34,10))
+        │   │   │       ├── flags: ∅
+        │   │   │       └── name: :_a
+        │   │   ├── optionals: (length: 0)
+        │   │   ├── rest: ∅
+        │   │   ├── posts: (length: 0)
+        │   │   ├── keywords: (length: 0)
+        │   │   ├── keyword_rest: ∅
+        │   │   └── block:
+        │   │       @ BlockParameterNode (location: (34,12)-(34,15))
+        │   │       ├── flags: repeated_parameter
+        │   │       ├── name: :_a
+        │   │       ├── name_loc: (34,13)-(34,15) = "_a"
+        │   │       └── operator_loc: (34,12)-(34,13) = "&"
+        │   ├── body: ∅
+        │   ├── locals: [:_a]
+        │   ├── locals_body_index: 1
+        │   ├── def_keyword_loc: (34,0)-(34,3) = "def"
+        │   ├── operator_loc: ∅
+        │   ├── lparen_loc: (34,7)-(34,8) = "("
+        │   ├── rparen_loc: (34,15)-(34,16) = ")"
+        │   ├── equal_loc: ∅
+        │   └── end_keyword_loc: (35,0)-(35,3) = "end"
+        └── @ DefNode (location: (37,0)-(38,3))
+            ├── name: :foo
+            ├── name_loc: (37,4)-(37,7) = "foo"
+            ├── receiver: ∅
+            ├── parameters:
+            │   @ ParametersNode (location: (37,8)-(37,15))
+            │   ├── requireds: (length: 1)
+            │   │   └── @ RequiredParameterNode (location: (37,8)-(37,10))
+            │   │       ├── flags: ∅
+            │   │       └── name: :_a
+            │   ├── optionals: (length: 0)
+            │   ├── rest:
+            │   │   @ RestParameterNode (location: (37,12)-(37,15))
+            │   │   ├── flags: repeated_parameter
+            │   │   ├── name: :_a
+            │   │   ├── name_loc: (37,13)-(37,15) = "_a"
+            │   │   └── operator_loc: (37,12)-(37,13) = "*"
+            │   ├── posts: (length: 0)
+            │   ├── keywords: (length: 0)
+            │   ├── keyword_rest: ∅
+            │   └── block: ∅
+            ├── body: ∅
+            ├── locals: [:_a]
+            ├── locals_body_index: 1
+            ├── def_keyword_loc: (37,0)-(37,3) = "def"
+            ├── operator_loc: ∅
+            ├── lparen_loc: (37,7)-(37,8) = "("
+            ├── rparen_loc: (37,15)-(37,16) = ")"
+            ├── equal_loc: ∅
+            └── end_keyword_loc: (38,0)-(38,3) = "end"

test/prism/snapshots/rescue.txt

@@ -170,6 +170,7 @@
         │       │   │   @ ParametersNode (location: (18,8)-(18,9))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (18,8)-(18,9))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :x
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/TestRubyParserShared.txt

@@ -134,8 +134,10 @@
         │   │           │   @ ParametersNode (location: (52,13)-(53,9))
         │   │           │   ├── requireds: (length: 2)
         │   │           │   │   ├── @ RequiredParameterNode (location: (52,13)-(52,14))
+        │   │           │   │   │   ├── flags: ∅
         │   │           │   │   │   └── name: :a
         │   │           │   │   └── @ RequiredParameterNode (location: (53,8)-(53,9))
+        │   │           │   │       ├── flags: ∅
         │   │           │   │       └── name: :b
         │   │           │   ├── optionals: (length: 0)
         │   │           │   ├── rest: ∅
@@ -227,8 +229,10 @@
         │   │           │   @ ParametersNode (location: (67,8)-(68,9))
         │   │           │   ├── requireds: (length: 2)
         │   │           │   │   ├── @ RequiredParameterNode (location: (67,8)-(67,9))
+        │   │           │   │   │   ├── flags: ∅
         │   │           │   │   │   └── name: :a
         │   │           │   │   └── @ RequiredParameterNode (location: (68,8)-(68,9))
+        │   │           │   │       ├── flags: ∅
         │   │           │   │       └── name: :b
         │   │           │   ├── optionals: (length: 0)
         │   │           │   ├── rest: ∅

test/prism/snapshots/seattlerb/args_kw_block.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
+            │   │       ├── flags: ∅
             │   │       ├── name: :a
             │   │       ├── name_loc: (1,6)-(1,8) = "a:"
             │   │       └── value:
@@ -23,6 +24,7 @@
             │   ├── keyword_rest: ∅
             │   └── block:
             │       @ BlockParameterNode (location: (1,12)-(1,14))
+            │       ├── flags: ∅
             │       ├── name: :b
             │       ├── name_loc: (1,13)-(1,14) = "b"
             │       └── operator_loc: (1,12)-(1,13) = "&"

test/prism/snapshots/seattlerb/block_arg__bare.txt

@@ -17,6 +17,7 @@
             │   ├── keyword_rest: ∅
             │   └── block:
             │       @ BlockParameterNode (location: (1,6)-(1,7))
+            │       ├── flags: ∅
             │       ├── name: ∅
             │       ├── name_loc: ∅
             │       └── operator_loc: (1,6)-(1,7) = "&"

test/prism/snapshots/seattlerb/block_arg_kwsplat.txt

@@ -27,6 +27,7 @@
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest:
                 │   │   │   @ KeywordRestParameterNode (location: (1,5)-(1,8))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :b
                 │   │   │   ├── name_loc: (1,7)-(1,8) = "b"
                 │   │   │   └── operator_loc: (1,5)-(1,7) = "**"

test/prism/snapshots/seattlerb/block_arg_opt_arg_block.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,18))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                 │   │   │       ├── operator_loc: (1,9)-(1,10) = "="
@@ -34,11 +36,13 @@
                 │   │   ├── rest: ∅
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :d
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅
                 │   │   └── block:
                 │   │       @ BlockParameterNode (location: (1,16)-(1,18))
+                │   │       ├── flags: ∅
                 │   │       ├── name: :e
                 │   │       ├── name_loc: (1,17)-(1,18) = "e"
                 │   │       └── operator_loc: (1,16)-(1,17) = "&"

test/prism/snapshots/seattlerb/block_arg_opt_splat.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,17))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,13))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                 │   │   │       ├── operator_loc: (1,10)-(1,11) = "="
@@ -33,6 +35,7 @@
                 │   │   │           └── flags: decimal
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,15)-(1,17))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :d
                 │   │   │   ├── name_loc: (1,16)-(1,17) = "d"
                 │   │   │   └── operator_loc: (1,15)-(1,16) = "*"

test/prism/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,22))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                 │   │   │       ├── operator_loc: (1,9)-(1,10) = "="
@@ -33,16 +35,19 @@
                 │   │   │           └── flags: decimal
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,13)-(1,15))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :d
                 │   │   │   ├── name_loc: (1,14)-(1,15) = "d"
                 │   │   │   └── operator_loc: (1,13)-(1,14) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,17)-(1,18))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :e
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅
                 │   │   └── block:
                 │   │       @ BlockParameterNode (location: (1,20)-(1,22))
+                │   │       ├── flags: ∅
                 │   │       ├── name: :f
                 │   │       ├── name_loc: (1,21)-(1,22) = "f"
                 │   │       └── operator_loc: (1,20)-(1,21) = "&"

test/prism/snapshots/seattlerb/block_arg_optional.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,10))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                 │   │   │       ├── operator_loc: (1,7)-(1,8) = "="

test/prism/snapshots/seattlerb/block_arg_scope.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,6))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅
@@ -31,6 +32,7 @@
                 │   │   └── block: ∅
                 │   ├── locals: (length: 1)
                 │   │   └── @ BlockLocalVariableNode (location: (1,8)-(1,9))
+                │   │       ├── flags: ∅
                 │   │       └── name: :c
                 │   ├── opening_loc: (1,4)-(1,5) = "|"
                 │   └── closing_loc: (1,9)-(1,10) = "|"

test/prism/snapshots/seattlerb/block_arg_scope2.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,4)-(1,5))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,4)-(1,5))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅
@@ -31,8 +32,10 @@
                 │   │   └── block: ∅
                 │   ├── locals: (length: 2)
                 │   │   ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
+                │   │   │   ├── flags: ∅
                 │   │   │   └── name: :c
                 │   │   └── @ BlockLocalVariableNode (location: (1,10)-(1,11))
+                │   │       ├── flags: ∅
                 │   │       └── name: :d
                 │   ├── opening_loc: (1,3)-(1,4) = "|"
                 │   └── closing_loc: (1,11)-(1,12) = "|"

test/prism/snapshots/seattlerb/block_arg_splat_arg.txt

@@ -22,15 +22,18 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,13))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,8)-(1,10))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :c
                 │   │   │   ├── name_loc: (1,9)-(1,10) = "c"
                 │   │   │   └── operator_loc: (1,8)-(1,9) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :d
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/block_args_kwargs.txt

@@ -27,6 +27,7 @@
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest:
                 │   │   │   @ KeywordRestParameterNode (location: (1,5)-(1,13))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :kwargs
                 │   │   │   ├── name_loc: (1,7)-(1,13) = "kwargs"
                 │   │   │   └── operator_loc: (1,5)-(1,7) = "**"

test/prism/snapshots/seattlerb/block_args_opt1.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,14))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :a
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,8)-(1,9) = "b"
                 │   │   │       ├── operator_loc: (1,10)-(1,11) = "="

test/prism/snapshots/seattlerb/block_args_opt2.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 2)
                 │   │   │   ├── @ OptionalParameterNode (location: (1,6)-(1,9))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   ├── name: :b
                 │   │   │   │   ├── name_loc: (1,6)-(1,7) = "b"
                 │   │   │   │   ├── operator_loc: (1,7)-(1,8) = "="
@@ -30,6 +31,7 @@
                 │   │   │   │       @ IntegerNode (location: (1,8)-(1,9))
                 │   │   │   │       └── flags: decimal
                 │   │   │   └── @ OptionalParameterNode (location: (1,11)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,11)-(1,12) = "c"
                 │   │   │       ├── operator_loc: (1,12)-(1,13) = "="

test/prism/snapshots/seattlerb/block_args_opt2_2.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,22))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :a
                 │   │   ├── optionals: (length: 2)
                 │   │   │   ├── @ OptionalParameterNode (location: (1,8)-(1,14))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   ├── name: :b
                 │   │   │   │   ├── name_loc: (1,8)-(1,9) = "b"
                 │   │   │   │   ├── operator_loc: (1,10)-(1,11) = "="
@@ -32,6 +34,7 @@
                 │   │   │   │       @ IntegerNode (location: (1,12)-(1,14))
                 │   │   │   │       └── flags: decimal
                 │   │   │   └── @ OptionalParameterNode (location: (1,16)-(1,22))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,16)-(1,17) = "c"
                 │   │   │       ├── operator_loc: (1,18)-(1,19) = "="

test/prism/snapshots/seattlerb/block_args_opt3.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,26))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :a
                 │   │   ├── optionals: (length: 2)
                 │   │   │   ├── @ OptionalParameterNode (location: (1,8)-(1,14))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   ├── name: :b
                 │   │   │   │   ├── name_loc: (1,8)-(1,9) = "b"
                 │   │   │   │   ├── operator_loc: (1,10)-(1,11) = "="
@@ -32,6 +34,7 @@
                 │   │   │   │       @ IntegerNode (location: (1,12)-(1,14))
                 │   │   │   │       └── flags: decimal
                 │   │   │   └── @ OptionalParameterNode (location: (1,16)-(1,22))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,16)-(1,17) = "c"
                 │   │   │       ├── operator_loc: (1,18)-(1,19) = "="
@@ -44,6 +47,7 @@
                 │   │   ├── keyword_rest: ∅
                 │   │   └── block:
                 │   │       @ BlockParameterNode (location: (1,24)-(1,26))
+                │   │       ├── flags: ∅
                 │   │       ├── name: :d
                 │   │       ├── name_loc: (1,25)-(1,26) = "d"
                 │   │       └── operator_loc: (1,24)-(1,25) = "&"

test/prism/snapshots/seattlerb/block_break.txt

@@ -40,6 +40,7 @@
             │               │   │   @ ParametersNode (location: (1,18)-(1,21))
             │               │   │   ├── requireds: (length: 1)
             │               │   │   │   └── @ RequiredParameterNode (location: (1,18)-(1,21))
+            │               │   │   │       ├── flags: ∅
             │               │   │   │       └── name: :bar
             │               │   │   ├── optionals: (length: 0)
             │               │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_call_defn_call_block_call.txt

@@ -22,6 +22,7 @@
         │   │           │   @ ParametersNode (location: (1,8)-(1,9))
         │   │           │   ├── requireds: (length: 1)
         │   │           │   │   └── @ RequiredParameterNode (location: (1,8)-(1,9))
+        │   │           │   │       ├── flags: ∅
         │   │           │   │       └── name: :c
         │   │           │   ├── optionals: (length: 0)
         │   │           │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_call_dot_op2_brace_block.txt

@@ -74,6 +74,7 @@
                 │   │   @ ParametersNode (location: (1,23)-(1,24))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,23)-(1,24))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :f
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt

@@ -87,6 +87,7 @@
                 │   │   @ ParametersNode (location: (1,25)-(1,26))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,25)-(1,26))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :g
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_decomp_anon_splat_arg.txt

@@ -29,6 +29,7 @@
                 │   │   │       │   └── expression: ∅
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :a
                 │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                 │   │   │       └── rparen_loc: (1,10)-(1,11) = ")"

test/prism/snapshots/seattlerb/block_decomp_arg_splat.txt

@@ -24,6 +24,7 @@
                 │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,11))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,9)-(1,10))

test/prism/snapshots/seattlerb/block_decomp_arg_splat_arg.txt

@@ -24,15 +24,18 @@
                 │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,15))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :a
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                 │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("
                 │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"

test/prism/snapshots/seattlerb/block_decomp_splat.txt

@@ -28,6 +28,7 @@
                 │   │   │       │   ├── operator_loc: (1,6)-(1,7) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,7)-(1,8))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :a
                 │   │   │       ├── rights: (length: 0)
                 │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("

test/prism/snapshots/seattlerb/block_kw.txt

@@ -26,6 +26,7 @@
                 │   │   ├── posts: (length: 0)
                 │   │   ├── keywords: (length: 1)
                 │   │   │   └── @ OptionalKeywordParameterNode (location: (1,8)-(1,12))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :k
                 │   │   │       ├── name_loc: (1,8)-(1,10) = "k:"
                 │   │   │       └── value:

test/prism/snapshots/seattlerb/block_kw__required.txt

@@ -26,6 +26,7 @@
                 │   │   ├── posts: (length: 0)
                 │   │   ├── keywords: (length: 1)
                 │   │   │   └── @ RequiredKeywordParameterNode (location: (1,9)-(1,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :k
                 │   │   │       └── name_loc: (1,9)-(1,11) = "k:"
                 │   │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/block_kwarg_lvar.txt

@@ -26,6 +26,7 @@
                 │   │   ├── posts: (length: 0)
                 │   │   ├── keywords: (length: 1)
                 │   │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :kw
                 │   │   │       ├── name_loc: (1,6)-(1,9) = "kw:"
                 │   │   │       └── value:

test/prism/snapshots/seattlerb/block_kwarg_lvar_multiple.txt

@@ -26,6 +26,7 @@
                 │   │   ├── posts: (length: 0)
                 │   │   ├── keywords: (length: 2)
                 │   │   │   ├── @ OptionalKeywordParameterNode (location: (1,6)-(1,14))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   ├── name: :kw
                 │   │   │   │   ├── name_loc: (1,6)-(1,9) = "kw:"
                 │   │   │   │   └── value:
@@ -36,6 +37,7 @@
                 │   │   │   │       ├── closing_loc: ∅
                 │   │   │   │       └── unescaped: "val"
                 │   │   │   └── @ OptionalKeywordParameterNode (location: (1,16)-(1,26))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :kw2
                 │   │   │       ├── name_loc: (1,16)-(1,20) = "kw2:"
                 │   │   │       └── value:

test/prism/snapshots/seattlerb/block_next.txt

@@ -40,6 +40,7 @@
             │               │   │   @ ParametersNode (location: (1,17)-(1,20))
             │               │   │   ├── requireds: (length: 1)
             │               │   │   │   └── @ RequiredParameterNode (location: (1,17)-(1,20))
+            │               │   │   │       ├── flags: ∅
             │               │   │   │       └── name: :bar
             │               │   │   ├── optionals: (length: 0)
             │               │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_opt_arg.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,8))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                 │   │   │       ├── operator_loc: (1,6)-(1,7) = "="
@@ -32,6 +33,7 @@
                 │   │   ├── rest: ∅
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :c
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/block_opt_splat.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,10))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                 │   │   │       ├── operator_loc: (1,7)-(1,8) = "="
@@ -31,6 +32,7 @@
                 │   │   │           └── flags: decimal
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,12)-(1,14))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :c
                 │   │   │   ├── name_loc: (1,13)-(1,14) = "c"
                 │   │   │   └── operator_loc: (1,12)-(1,13) = "*"

test/prism/snapshots/seattlerb/block_opt_splat_arg_block_omfg.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,8))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                 │   │   │       ├── operator_loc: (1,6)-(1,7) = "="
@@ -31,16 +32,19 @@
                 │   │   │           └── flags: decimal
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,10)-(1,12))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :c
                 │   │   │   ├── name_loc: (1,11)-(1,12) = "c"
                 │   │   │   └── operator_loc: (1,10)-(1,11) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :d
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅
                 │   │   └── block:
                 │   │       @ BlockParameterNode (location: (1,17)-(1,19))
+                │   │       ├── flags: ∅
                 │   │       ├── name: :e
                 │   │       ├── name_loc: (1,18)-(1,19) = "e"
                 │   │       └── operator_loc: (1,17)-(1,18) = "&"

test/prism/snapshots/seattlerb/block_optarg.txt

@@ -23,6 +23,7 @@
                 │   │   ├── requireds: (length: 0)
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,5)-(1,11))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :b
                 │   │   │       ├── name_loc: (1,5)-(1,6) = "b"
                 │   │   │       ├── operator_loc: (1,7)-(1,8) = "="

test/prism/snapshots/seattlerb/block_paren_splat.txt

@@ -24,12 +24,14 @@
                 │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,12))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,9)-(1,11))
                 │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── rights: (length: 0)
                 │   │   │       ├── lparen_loc: (1,5)-(1,6) = "("

test/prism/snapshots/seattlerb/block_reg_optarg.txt

@@ -22,9 +22,11 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,14))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── optionals: (length: 1)
                 │   │   │   └── @ OptionalParameterNode (location: (1,8)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       ├── name: :c
                 │   │   │       ├── name_loc: (1,8)-(1,9) = "c"
                 │   │   │       ├── operator_loc: (1,10)-(1,11) = "="

test/prism/snapshots/seattlerb/block_return.txt

@@ -41,6 +41,7 @@
                             │   │   @ ParametersNode (location: (1,19)-(1,22))
                             │   │   ├── requireds: (length: 1)
                             │   │   │   └── @ RequiredParameterNode (location: (1,19)-(1,22))
+                            │   │   │       ├── flags: ∅
                             │   │   │       └── name: :bar
                             │   │   ├── optionals: (length: 0)
                             │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/block_scope.txt

@@ -21,6 +21,7 @@
                 │   ├── parameters: ∅
                 │   ├── locals: (length: 1)
                 │   │   └── @ BlockLocalVariableNode (location: (1,6)-(1,7))
+                │   │       ├── flags: ∅
                 │   │       └── name: :b
                 │   ├── opening_loc: (1,4)-(1,5) = "|"
                 │   └── closing_loc: (1,7)-(1,8) = "|"

test/prism/snapshots/seattlerb/block_splat_reg.txt

@@ -24,11 +24,13 @@
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :b
                 │   │   │   ├── name_loc: (1,6)-(1,7) = "b"
                 │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :c
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/bug236.txt

@@ -22,6 +22,7 @@
         │       │   │   @ ParametersNode (location: (1,3)-(1,5))
         │       │   │   ├── requireds: (length: 1)
         │       │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
+        │       │   │   │       ├── flags: ∅
         │       │   │   │       └── name: :a
         │       │   │   ├── optionals: (length: 0)
         │       │   │   ├── rest:
@@ -55,6 +56,7 @@
                 │   │   @ ParametersNode (location: (3,3)-(3,4))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (3,3)-(3,4))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :a
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/bug_args__19.txt

@@ -24,8 +24,10 @@
                 │   │   │   └── @ MultiTargetNode (location: (1,5)-(1,11))
                 │   │   │       ├── lefts: (length: 2)
                 │   │   │       │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
+                │   │   │       │   │   ├── flags: ∅
                 │   │   │       │   │   └── name: :a
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest: ∅
                 │   │   │       ├── rights: (length: 0)

test/prism/snapshots/seattlerb/bug_args_masgn.txt

@@ -24,14 +24,17 @@
                 │   │   │   ├── @ MultiTargetNode (location: (1,5)-(1,11))
                 │   │   │   │   ├── lefts: (length: 2)
                 │   │   │   │   │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
+                │   │   │   │   │   │   ├── flags: ∅
                 │   │   │   │   │   │   └── name: :a
                 │   │   │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │   │   │       ├── flags: ∅
                 │   │   │   │   │       └── name: :b
                 │   │   │   │   ├── rest: ∅
                 │   │   │   │   ├── rights: (length: 0)
                 │   │   │   │   ├── lparen_loc: (1,5)-(1,6) = "("
                 │   │   │   │   └── rparen_loc: (1,10)-(1,11) = ")"
                 │   │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :c
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/bug_args_masgn2.txt

@@ -26,20 +26,24 @@
                 │   │   │   │   │   ├── @ MultiTargetNode (location: (1,6)-(1,12))
                 │   │   │   │   │   │   ├── lefts: (length: 2)
                 │   │   │   │   │   │   │   ├── @ RequiredParameterNode (location: (1,7)-(1,8))
+                │   │   │   │   │   │   │   │   ├── flags: ∅
                 │   │   │   │   │   │   │   │   └── name: :a
                 │   │   │   │   │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │   │   │   │   │       ├── flags: ∅
                 │   │   │   │   │   │   │       └── name: :b
                 │   │   │   │   │   │   ├── rest: ∅
                 │   │   │   │   │   │   ├── rights: (length: 0)
                 │   │   │   │   │   │   ├── lparen_loc: (1,6)-(1,7) = "("
                 │   │   │   │   │   │   └── rparen_loc: (1,11)-(1,12) = ")"
                 │   │   │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
+                │   │   │   │   │       ├── flags: ∅
                 │   │   │   │   │       └── name: :c
                 │   │   │   │   ├── rest: ∅
                 │   │   │   │   ├── rights: (length: 0)
                 │   │   │   │   ├── lparen_loc: (1,5)-(1,6) = "("
                 │   │   │   │   └── rparen_loc: (1,15)-(1,16) = ")"
                 │   │   │   └── @ RequiredParameterNode (location: (1,18)-(1,19))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :d
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/bug_args_masgn_outer_parens__19.txt

@@ -26,14 +26,17 @@
                 │   │   │       │   ├── @ MultiTargetNode (location: (1,6)-(1,12))
                 │   │   │       │   │   ├── lefts: (length: 2)
                 │   │   │       │   │   │   ├── @ RequiredParameterNode (location: (1,7)-(1,8))
+                │   │   │       │   │   │   │   ├── flags: ∅
                 │   │   │       │   │   │   │   └── name: :k
                 │   │   │       │   │   │   └── @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       │   │   │       ├── flags: ∅
                 │   │   │       │   │   │       └── name: :v
                 │   │   │       │   │   ├── rest: ∅
                 │   │   │       │   │   ├── rights: (length: 0)
                 │   │   │       │   │   ├── lparen_loc: (1,6)-(1,7) = "("
                 │   │   │       │   │   └── rparen_loc: (1,11)-(1,12) = ")"
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,14)-(1,15))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :i
                 │   │   │       ├── rest: ∅
                 │   │   │       ├── rights: (length: 0)

test/prism/snapshots/seattlerb/bug_masgn_right.txt

@@ -22,12 +22,15 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,14))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                 │   │   │       ├── lefts: (length: 2)
                 │   │   │       │   ├── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │   │   ├── flags: ∅
                 │   │   │       │   │   └── name: :b
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── rest: ∅
                 │   │   │       ├── rights: (length: 0)

test/prism/snapshots/seattlerb/case_in.txt

@@ -557,6 +557,7 @@
         │   │       │   │   │   │   │   @ ParametersNode (location: (70,7)-(70,8))
         │   │       │   │   │   │   │   ├── requireds: (length: 1)
         │   │       │   │   │   │   │   │   └── @ RequiredParameterNode (location: (70,7)-(70,8))
+        │   │       │   │   │   │   │   │       ├── flags: ∅
         │   │       │   │   │   │   │   │       └── name: :b
         │   │       │   │   │   │   │   ├── optionals: (length: 0)
         │   │       │   │   │   │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_arg_asplat_arg.txt

@@ -11,15 +11,18 @@
             │   @ ParametersNode (location: (1,9)-(1,24))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,9)-(1,15))
+            │   │       ├── flags: ∅
             │   │       └── name: :interp
             │   ├── optionals: (length: 0)
             │   ├── rest:
             │   │   @ RestParameterNode (location: (1,17)-(1,18))
+            │   │   ├── flags: ∅
             │   │   ├── name: ∅
             │   │   ├── name_loc: ∅
             │   │   └── operator_loc: (1,17)-(1,18) = "*"
             │   ├── posts: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,20)-(1,24))
+            │   │       ├── flags: ∅
             │   │       └── name: :args
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/defn_arg_forward_args.txt

@@ -11,6 +11,7 @@
             │   @ ParametersNode (location: (1,6)-(1,12))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+            │   │       ├── flags: ∅
             │   │       └── name: :x
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_args_forward_args.txt

@@ -11,10 +11,13 @@
             │   @ ParametersNode (location: (1,6)-(1,18))
             │   ├── requireds: (length: 3)
             │   │   ├── @ RequiredParameterNode (location: (1,6)-(1,7))
+            │   │   │   ├── flags: ∅
             │   │   │   └── name: :x
             │   │   ├── @ RequiredParameterNode (location: (1,9)-(1,10))
+            │   │   │   ├── flags: ∅
             │   │   │   └── name: :y
             │   │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
+            │   │       ├── flags: ∅
             │   │       └── name: :z
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_kwarg_env.txt

@@ -16,6 +16,7 @@
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest:
             │   │   @ KeywordRestParameterNode (location: (1,9)-(1,18))
+            │   │   ├── flags: ∅
             │   │   ├── name: :testing
             │   │   ├── name_loc: (1,11)-(1,18) = "testing"
             │   │   └── operator_loc: (1,9)-(1,11) = "**"

test/prism/snapshots/seattlerb/defn_kwarg_kwarg.txt

@@ -11,18 +11,21 @@
             │   @ ParametersNode (location: (1,6)-(1,19))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+            │   │       ├── flags: ∅
             │   │       └── name: :a
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 2)
             │   │   ├── @ OptionalKeywordParameterNode (location: (1,9)-(1,13))
+            │   │   │   ├── flags: ∅
             │   │   │   ├── name: :b
             │   │   │   ├── name_loc: (1,9)-(1,11) = "b:"
             │   │   │   └── value:
             │   │   │       @ IntegerNode (location: (1,12)-(1,13))
             │   │   │       └── flags: decimal
             │   │   └── @ OptionalKeywordParameterNode (location: (1,15)-(1,19))
+            │   │       ├── flags: ∅
             │   │       ├── name: :c
             │   │       ├── name_loc: (1,15)-(1,17) = "c:"
             │   │       └── value:

test/prism/snapshots/seattlerb/defn_kwarg_kwsplat.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
+            │   │       ├── flags: ∅
             │   │       ├── name: :b
             │   │       ├── name_loc: (1,6)-(1,8) = "b:"
             │   │       └── value:
@@ -22,6 +23,7 @@
             │   │           └── flags: decimal
             │   ├── keyword_rest:
             │   │   @ KeywordRestParameterNode (location: (1,12)-(1,15))
+            │   │   ├── flags: ∅
             │   │   ├── name: :c
             │   │   ├── name_loc: (1,14)-(1,15) = "c"
             │   │   └── operator_loc: (1,12)-(1,14) = "**"

test/prism/snapshots/seattlerb/defn_kwarg_kwsplat_anon.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
+            │   │       ├── flags: ∅
             │   │       ├── name: :b
             │   │       ├── name_loc: (1,6)-(1,8) = "b:"
             │   │       └── value:
@@ -22,6 +23,7 @@
             │   │           └── flags: decimal
             │   ├── keyword_rest:
             │   │   @ KeywordRestParameterNode (location: (1,12)-(1,14))
+            │   │   ├── flags: ∅
             │   │   ├── name: ∅
             │   │   ├── name_loc: ∅
             │   │   └── operator_loc: (1,12)-(1,14) = "**"

test/prism/snapshots/seattlerb/defn_kwarg_lvar.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,8)-(1,16))
+            │   │       ├── flags: ∅
             │   │       ├── name: :kw
             │   │       ├── name_loc: (1,8)-(1,11) = "kw:"
             │   │       └── value:

test/prism/snapshots/seattlerb/defn_kwarg_no_parens.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
+            │   │       ├── flags: ∅
             │   │       ├── name: :a
             │   │       ├── name_loc: (1,6)-(1,8) = "a:"
             │   │       └── value:

test/prism/snapshots/seattlerb/defn_kwarg_val.txt

@@ -11,12 +11,14 @@
             │   @ ParametersNode (location: (1,6)-(1,12))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+            │   │       ├── flags: ∅
             │   │       └── name: :a
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,9)-(1,12))
+            │   │       ├── flags: ∅
             │   │       ├── name: :b
             │   │       ├── name_loc: (1,9)-(1,11) = "b:"
             │   │       └── value:

test/prism/snapshots/seattlerb/defn_oneliner.txt

@@ -11,6 +11,7 @@
             │   @ ParametersNode (location: (1,9)-(1,12))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,9)-(1,12))
+            │   │       ├── flags: ∅
             │   │       └── name: :cmd
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_oneliner_eq2.txt

@@ -22,6 +22,7 @@
             │           │   @ ParametersNode (location: (2,9)-(2,10))
             │           │   ├── requireds: (length: 1)
             │           │   │   └── @ RequiredParameterNode (location: (2,9)-(2,10))
+            │           │   │       ├── flags: ∅
             │           │   │       └── name: :o
             │           │   ├── optionals: (length: 0)
             │           │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_oneliner_rescue.txt

@@ -11,6 +11,7 @@
         │   │   @ ParametersNode (location: (1,9)-(1,12))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,12))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :cmd
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -70,6 +71,7 @@
         │   │   @ ParametersNode (location: (8,9)-(8,12))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (8,9)-(8,12))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :cmd
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -117,6 +119,7 @@
             │   @ ParametersNode (location: (13,9)-(13,12))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (13,9)-(13,12))
+            │   │       ├── flags: ∅
             │   │       └── name: :cmd
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/defn_opt_last_arg.txt

@@ -12,6 +12,7 @@
             │   ├── requireds: (length: 0)
             │   ├── optionals: (length: 1)
             │   │   └── @ OptionalParameterNode (location: (1,6)-(1,17))
+            │   │       ├── flags: ∅
             │   │       ├── name: :arg
             │   │       ├── name_loc: (1,6)-(1,9) = "arg"
             │   │       ├── operator_loc: (1,10)-(1,11) = "="

test/prism/snapshots/seattlerb/defn_opt_reg.txt

@@ -12,6 +12,7 @@
             │   ├── requireds: (length: 0)
             │   ├── optionals: (length: 1)
             │   │   └── @ OptionalParameterNode (location: (1,6)-(1,11))
+            │   │       ├── flags: ∅
             │   │       ├── name: :a
             │   │       ├── name_loc: (1,6)-(1,7) = "a"
             │   │       ├── operator_loc: (1,7)-(1,8) = "="
@@ -20,6 +21,7 @@
             │   ├── rest: ∅
             │   ├── posts: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
+            │   │       ├── flags: ∅
             │   │       └── name: :b
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/defn_opt_splat_arg.txt

@@ -12,6 +12,7 @@
             │   ├── requireds: (length: 0)
             │   ├── optionals: (length: 1)
             │   │   └── @ OptionalParameterNode (location: (1,7)-(1,12))
+            │   │       ├── flags: ∅
             │   │       ├── name: :a
             │   │       ├── name_loc: (1,7)-(1,8) = "a"
             │   │       ├── operator_loc: (1,9)-(1,10) = "="
@@ -20,11 +21,13 @@
             │   │           └── flags: decimal
             │   ├── rest:
             │   │   @ RestParameterNode (location: (1,14)-(1,16))
+            │   │   ├── flags: ∅
             │   │   ├── name: :b
             │   │   ├── name_loc: (1,15)-(1,16) = "b"
             │   │   └── operator_loc: (1,14)-(1,15) = "*"
             │   ├── posts: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,18)-(1,19))
+            │   │       ├── flags: ∅
             │   │       └── name: :c
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/defn_powarg.txt

@@ -16,6 +16,7 @@
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest:
             │   │   @ KeywordRestParameterNode (location: (1,6)-(1,12))
+            │   │   ├── flags: ∅
             │   │   ├── name: :opts
             │   │   ├── name_loc: (1,8)-(1,12) = "opts"
             │   │   └── operator_loc: (1,6)-(1,8) = "**"

test/prism/snapshots/seattlerb/defn_reg_opt_reg.txt

@@ -11,9 +11,11 @@
             │   @ ParametersNode (location: (1,6)-(1,18))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,6)-(1,7))
+            │   │       ├── flags: ∅
             │   │       └── name: :a
             │   ├── optionals: (length: 1)
             │   │   └── @ OptionalParameterNode (location: (1,9)-(1,15))
+            │   │       ├── flags: ∅
             │   │       ├── name: :b
             │   │       ├── name_loc: (1,9)-(1,10) = "b"
             │   │       ├── operator_loc: (1,11)-(1,12) = "="
@@ -27,6 +29,7 @@
             │   ├── rest: ∅
             │   ├── posts: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,17)-(1,18))
+            │   │       ├── flags: ∅
             │   │       └── name: :d
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/defn_splat_arg.txt

@@ -13,11 +13,13 @@
             │   ├── optionals: (length: 0)
             │   ├── rest:
             │   │   @ RestParameterNode (location: (1,6)-(1,7))
+            │   │   ├── flags: ∅
             │   │   ├── name: ∅
             │   │   ├── name_loc: ∅
             │   │   └── operator_loc: (1,6)-(1,7) = "*"
             │   ├── posts: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+            │   │       ├── flags: ∅
             │   │       └── name: :a
             │   ├── keywords: (length: 0)
             │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/defs_kwarg.txt

@@ -16,6 +16,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,11)-(1,15))
+            │   │       ├── flags: ∅
             │   │       ├── name: :b
             │   │       ├── name_loc: (1,11)-(1,13) = "b:"
             │   │       └── value:

test/prism/snapshots/seattlerb/defs_oneliner.txt

@@ -12,6 +12,7 @@
             │   @ ParametersNode (location: (1,14)-(1,17))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
+            │   │       ├── flags: ∅
             │   │       └── name: :cmd
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/defs_oneliner_eq2.txt

@@ -23,6 +23,7 @@
             │           │   @ ParametersNode (location: (2,14)-(2,15))
             │           │   ├── requireds: (length: 1)
             │           │   │   └── @ RequiredParameterNode (location: (2,14)-(2,15))
+            │           │   │       ├── flags: ∅
             │           │   │       └── name: :o
             │           │   ├── optionals: (length: 0)
             │           │   ├── rest: ∅

test/prism/snapshots/seattlerb/defs_oneliner_rescue.txt

@@ -12,6 +12,7 @@
         │   │   @ ParametersNode (location: (1,14)-(1,17))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (1,14)-(1,17))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :cmd
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -72,6 +73,7 @@
         │   │   @ ParametersNode (location: (8,14)-(8,17))
         │   │   ├── requireds: (length: 1)
         │   │   │   └── @ RequiredParameterNode (location: (8,14)-(8,17))
+        │   │   │       ├── flags: ∅
         │   │   │       └── name: :cmd
         │   │   ├── optionals: (length: 0)
         │   │   ├── rest: ∅
@@ -120,6 +122,7 @@
             │   @ ParametersNode (location: (13,14)-(13,17))
             │   ├── requireds: (length: 1)
             │   │   └── @ RequiredParameterNode (location: (13,14)-(13,17))
+            │   │       ├── flags: ∅
             │   │       └── name: :cmd
             │   ├── optionals: (length: 0)
             │   ├── rest: ∅

test/prism/snapshots/seattlerb/difficult3_.txt

@@ -22,16 +22,19 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,15))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,15))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,12)-(1,14))
                 │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── rights: (length: 0)
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("

test/prism/snapshots/seattlerb/difficult3_2.txt

@@ -24,11 +24,13 @@
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :a
                 │   │   │   ├── name_loc: (1,6)-(1,7) = "a"
                 │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅

test/prism/snapshots/seattlerb/difficult3_3.txt

@@ -24,16 +24,19 @@
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest:
                 │   │   │   @ RestParameterNode (location: (1,5)-(1,7))
+                │   │   │   ├── flags: ∅
                 │   │   │   ├── name: :a
                 │   │   │   ├── name_loc: (1,6)-(1,7) = "a"
                 │   │   │   └── operator_loc: (1,5)-(1,6) = "*"
                 │   │   ├── posts: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :b
                 │   │   ├── keywords: (length: 0)
                 │   │   ├── keyword_rest: ∅
                 │   │   └── block:
                 │   │       @ BlockParameterNode (location: (1,12)-(1,14))
+                │   │       ├── flags: ∅
                 │   │       ├── name: :c
                 │   │       ├── name_loc: (1,13)-(1,14) = "c"
                 │   │       └── operator_loc: (1,12)-(1,13) = "&"

test/prism/snapshots/seattlerb/difficult3__10.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,15))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,15))
                 │   │   │       ├── lefts: (length: 0)
@@ -30,9 +31,11 @@
                 │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                 │   │   │       └── rparen_loc: (1,14)-(1,15) = ")"

test/prism/snapshots/seattlerb/difficult3__11.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,11))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,11))
                 │   │   │       ├── lefts: (length: 0)

test/prism/snapshots/seattlerb/difficult3__12.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,14))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                 │   │   │       ├── lefts: (length: 0)
@@ -31,6 +32,7 @@
                 │   │   │       │   └── expression: ∅
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,12)-(1,13))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                 │   │   │       └── rparen_loc: (1,13)-(1,14) = ")"

test/prism/snapshots/seattlerb/difficult3__6.txt

@@ -22,19 +22,23 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,18))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,18))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,12)-(1,14))
                 │   │   │       │   ├── operator_loc: (1,12)-(1,13) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,13)-(1,14))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,16)-(1,17))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :d
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                 │   │   │       └── rparen_loc: (1,17)-(1,18) = ")"

test/prism/snapshots/seattlerb/difficult3__7.txt

@@ -22,10 +22,12 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,14))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,14))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,12)-(1,13))

test/prism/snapshots/seattlerb/difficult3__8.txt

@@ -22,10 +22,12 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,17))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,17))
                 │   │   │       ├── lefts: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,9)-(1,10))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rest:
                 │   │   │       │   @ SplatNode (location: (1,12)-(1,13))
@@ -33,6 +35,7 @@
                 │   │   │       │   └── expression: ∅
                 │   │   │       ├── rights: (length: 1)
                 │   │   │       │   └── @ RequiredParameterNode (location: (1,15)-(1,16))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :c
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("
                 │   │   │       └── rparen_loc: (1,16)-(1,17) = ")"

test/prism/snapshots/seattlerb/difficult3__9.txt

@@ -22,6 +22,7 @@
                 │   │   @ ParametersNode (location: (1,5)-(1,12))
                 │   │   ├── requireds: (length: 2)
                 │   │   │   ├── @ RequiredParameterNode (location: (1,5)-(1,6))
+                │   │   │   │   ├── flags: ∅
                 │   │   │   │   └── name: :a
                 │   │   │   └── @ MultiTargetNode (location: (1,8)-(1,12))
                 │   │   │       ├── lefts: (length: 0)
@@ -30,6 +31,7 @@
                 │   │   │       │   ├── operator_loc: (1,9)-(1,10) = "*"
                 │   │   │       │   └── expression:
                 │   │   │       │       @ RequiredParameterNode (location: (1,10)-(1,11))
+                │   │   │       │       ├── flags: ∅
                 │   │   │       │       └── name: :b
                 │   │   │       ├── rights: (length: 0)
                 │   │   │       ├── lparen_loc: (1,8)-(1,9) = "("

test/prism/snapshots/seattlerb/difficult6_.txt

@@ -15,9 +15,11 @@
             │   │   @ ParametersNode (location: (1,3)-(1,11))
             │   │   ├── requireds: (length: 1)
             │   │   │   └── @ RequiredParameterNode (location: (1,3)-(1,4))
+            │   │   │       ├── flags: ∅
             │   │   │       └── name: :a
             │   │   ├── optionals: (length: 1)
             │   │   │   └── @ OptionalParameterNode (location: (1,6)-(1,11))
+            │   │   │       ├── flags: ∅
             │   │   │       ├── name: :b
             │   │   │       ├── name_loc: (1,6)-(1,7) = "b"
             │   │   │       ├── operator_loc: (1,7)-(1,8) = "="

test/prism/snapshots/seattlerb/do_bug.txt

@@ -47,6 +47,7 @@
                 │   │   @ ParametersNode (location: (2,8)-(2,9))
                 │   │   ├── requireds: (length: 1)
                 │   │   │   └── @ RequiredParameterNode (location: (2,8)-(2,9))
+                │   │   │       ├── flags: ∅
                 │   │   │       └── name: :c
                 │   │   ├── optionals: (length: 0)
                 │   │   ├── rest: ∅

test/prism/snapshots/seattlerb/f_kw.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ OptionalKeywordParameterNode (location: (1,6)-(1,10))
+            │   │       ├── flags: ∅
             │   │       ├── name: :k
             │   │       ├── name_loc: (1,6)-(1,8) = "k:"
             │   │       └── value:

test/prism/snapshots/seattlerb/f_kw__required.txt

@@ -15,6 +15,7 @@
             │   ├── posts: (length: 0)
             │   ├── keywords: (length: 1)
             │   │   └── @ RequiredKeywordParameterNode (location: (1,6)-(1,8))
+            │   │       ├── flags: ∅
             │   │       ├── name: :k
             │   │       └── name_loc: (1,6)-(1,8) = "k:"
             │   ├── keyword_rest: ∅