[ruby/prism] Change ConstantPathNode#child to ConstantPathNode#{name,name_loc}

This has been requested for a long time, and I'm finally doing it
now. Unfortunately this is a breaking change for all of the APIs.

I've added in a Ruby method for `#child` that is deprecated so that
existing usage doesn't break, but for everyone else this is going
to be a bit of a pain.

https://github.com/ruby/prism/commit/9cbe74464e

lib/prism/node_ext.rb

@@ -143,11 +143,12 @@ module Prism
       current = self #: node?
 
       while current.is_a?(ConstantPathNode)
-        child = current.child
+        name = current.name
-        if child.is_a?(MissingNode)
+        if name.nil?
           raise MissingNodesInConstantPathError, "Constant path contains missing nodes. Cannot compute full name"
         end
-        parts.unshift(child.name)
+
+        parts.unshift(name)
         current = current.parent
       end
 
@@ -162,6 +163,20 @@ module Prism
     def full_name
       full_name_parts.join("::")
     end
+
+    # Previously, we had a child node on this class that contained either a
+    # constant read or a missing node. To not cause a breaking change, we
+    # continue to supply that API.
+    def child
+      warn(<<~MSG, category: :deprecated)
+        DEPRECATED: ConstantPathNode#child is deprecated and will be removed \
+        in the next major version. Use \
+        ConstantPathNode#name/ConstantPathNode#name_loc instead. Called from \
+        #{caller(1..1).first}.
+      MSG
+
+      name ? ConstantReadNode.new(source, name, name_loc) : MissingNode.new(source, location)
+    end
   end
 
   class ConstantPathTargetNode < Node
@@ -179,17 +194,31 @@ module Prism
           raise ConstantPathNode::DynamicPartsInConstantPathError, "Constant target path contains dynamic parts. Cannot compute full name"
         end
 
-      if child.is_a?(MissingNode)
+      if name.nil?
         raise ConstantPathNode::MissingNodesInConstantPathError, "Constant target path contains missing nodes. Cannot compute full name"
       end
 
-      parts.push(child.name)
+      parts.push(name)
     end
 
     # Returns the full name of this constant path. For example: "Foo::Bar"
     def full_name
       full_name_parts.join("::")
     end
+
+    # Previously, we had a child node on this class that contained either a
+    # constant read or a missing node. To not cause a breaking change, we
+    # continue to supply that API.
+    def child
+      warn(<<~MSG, category: :deprecated)
+        DEPRECATED: ConstantPathTargetNode#child is deprecated and will be \
+        removed in the next major version. Use \
+        ConstantPathTargetNode#name/ConstantPathTargetNode#name_loc instead. \
+        Called from #{caller(1..1).first}.
+      MSG
+
+      name ? ConstantReadNode.new(source, name, name_loc) : MissingNode.new(source, location)
+    end
   end
 
   class ConstantTargetNode < Node

lib/prism/pattern.rb

@@ -149,7 +149,7 @@ module Prism
       parent = node.parent
 
       if parent.is_a?(ConstantReadNode) && parent.slice == "Prism"
-        compile_node(node.child)
+        compile_constant_name(node, node.name)
       else
         compile_error(node)
       end
@@ -158,14 +158,17 @@ module Prism
     # in ConstantReadNode
     # in String
     def compile_constant_read_node(node)
-      value = node.slice
+      compile_constant_name(node, node.name)
+    end
 
-      if Prism.const_defined?(value, false)
+    # Compile a name associated with a constant.
-        clazz = Prism.const_get(value)
+    def compile_constant_name(node, name)
+      if Prism.const_defined?(name, false)
+        clazz = Prism.const_get(name)
 
         ->(other) { clazz === other }
-      elsif Object.const_defined?(value, false)
+      elsif Object.const_defined?(name, false)
-        clazz = Object.const_get(value)
+        clazz = Object.const_get(name)
 
         ->(other) { clazz === other }
       else

lib/prism/translation/parser/compiler.rb

@@ -483,13 +483,13 @@ module Prism
           if node.parent.nil?
             builder.const_global(
               token(node.delimiter_loc),
-              [node.child.name, srange(node.child.location)]
+              [node.name, srange(node.name_loc)]
             )
           else
             builder.const_fetch(
               visit(node.parent),
               token(node.delimiter_loc),
-              [node.child.name, srange(node.child.location)]
+              [node.name, srange(node.name_loc)]
             )
           end
         end

lib/prism/translation/ripper.rb

@@ -1456,16 +1456,16 @@ module Prism
       # ^^^^^^^^
       def visit_constant_path_node(node)
         if node.parent.nil?
-          bounds(node.child.location)
+          bounds(node.name_loc)
-          child = on_const(node.child.name.to_s)
+          child = on_const(node.name.to_s)
 
           bounds(node.location)
           on_top_const_ref(child)
         else
           parent = visit(node.parent)
 
-          bounds(node.child.location)
+          bounds(node.name_loc)
-          child = on_const(node.child.name.to_s)
+          child = on_const(node.name.to_s)
 
           bounds(node.location)
           on_const_path_ref(parent, child)

lib/prism/translation/ruby_parser.rb

@@ -442,9 +442,9 @@ module Prism
         # ^^^^^^^^
         def visit_constant_path_node(node)
           if node.parent.nil?
-            s(node, :colon3, node.child.name)
+            s(node, :colon3, node.name)
           else
-            s(node, :colon2, visit(node.parent), node.child.name)
+            s(node, :colon2, visit(node.parent), node.name)
           end
         end
 

prism/config.yml

@@ -1520,23 +1520,9 @@ nodes:
 
               a.b::C
               ^^^
-      - name: child
+      - name: name
-        type: node
+        type: constant?
-        kind:
+        comment: The name of the constant being accessed. This could be `nil` in the event of a syntax error.
-          - ConstantReadNode
-          - MissingNode
-        comment: |
-          The right-hand node of the path. Always a `ConstantReadNode` in a
-          valid Ruby syntax tree.
-
-              ::Foo
-                ^^^
-
-              self::Test
-                    ^^^^
-
-              a.b::C
-                   ^
       - name: delimiter_loc
         type: location
         comment: |
@@ -1547,6 +1533,16 @@ nodes:
 
               One::Two
                  ^^
+      - name: name_loc
+        type: location
+        comment: |
+          The location of the name of the constant.
+
+              ::Foo
+                ^^^
+
+              One::Two
+                   ^^^
     comment: |
       Represents accessing a constant through a path of `::` operators.
 
@@ -1586,13 +1582,12 @@ nodes:
     fields:
       - name: parent
         type: node?
-      - name: child
+      - name: name
-        type: node
+        type: constant?
-        kind:
-          - ConstantReadNode
-          - MissingNode
       - name: delimiter_loc
         type: location
+      - name: name_loc
+        type: location
     comment: |
       Represents writing to a constant path in a context that doesn't have an explicit value.
 

prism/prism.c

@@ -3530,22 +3530,27 @@ pm_constant_path_or_write_node_create(pm_parser_t *parser, pm_constant_path_node
  * Allocate and initialize a new ConstantPathNode node.
  */
 static pm_constant_path_node_t *
-pm_constant_path_node_create(pm_parser_t *parser, pm_node_t *parent, const pm_token_t *delimiter, pm_node_t *child) {
+pm_constant_path_node_create(pm_parser_t *parser, pm_node_t *parent, const pm_token_t *delimiter, const pm_token_t *name_token) {
     pm_assert_value_expression(parser, parent);
-
     pm_constant_path_node_t *node = PM_ALLOC_NODE(parser, pm_constant_path_node_t);
 
+    pm_constant_id_t name = PM_CONSTANT_ID_UNSET;
+    if (name_token->type == PM_TOKEN_CONSTANT) {
+        name = pm_parser_constant_id_token(parser, name_token);
+    }
+
     *node = (pm_constant_path_node_t) {
         {
             .type = PM_CONSTANT_PATH_NODE,
             .location = {
                 .start = parent == NULL ? delimiter->start : parent->location.start,
-                .end = child->location.end
+                .end = name_token->end
             },
         },
         .parent = parent,
-        .child = child,
+        .name = name,
-        .delimiter_loc = PM_LOCATION_TOKEN_VALUE(delimiter)
+        .delimiter_loc = PM_LOCATION_TOKEN_VALUE(delimiter),
+        .name_loc = PM_LOCATION_TOKEN_VALUE(name_token)
     };
 
     return node;
@@ -15823,9 +15828,7 @@ parse_pattern_constant_path(pm_parser_t *parser, pm_constant_id_list_t *captures
     while (accept1(parser, PM_TOKEN_COLON_COLON)) {
         pm_token_t delimiter = parser->previous;
         expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
-
+        node = (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
-        pm_node_t *child = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);
-        node = (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, child);
     }
 
     // If there is a [ or ( that follows, then this is part of a larger pattern
@@ -16404,8 +16407,7 @@ parse_pattern_primitive(pm_parser_t *parser, pm_constant_id_list_t *captures, pm
             parser_lex(parser);
 
             expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
-            pm_node_t *child = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);
+            pm_constant_path_node_t *node = pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous);
-            pm_constant_path_node_t *node = pm_constant_path_node_create(parser, NULL, &delimiter, child);
 
             return parse_pattern_constant_path(parser, captures, (pm_node_t *) node);
         }
@@ -17379,12 +17381,10 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
         }
         case PM_TOKEN_UCOLON_COLON: {
             parser_lex(parser);
-
             pm_token_t delimiter = parser->previous;
-            expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
 
-            pm_node_t *constant = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);
+            expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
-            pm_node_t *node = (pm_node_t *)pm_constant_path_node_create(parser, NULL, &delimiter, constant);
+            pm_node_t *node = (pm_node_t *) pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous);
 
             if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
                 node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX);
@@ -18642,9 +18642,7 @@ parse_expression_prefix(pm_parser_t *parser, pm_binding_power_t binding_power, b
                 pm_token_t double_colon = parser->previous;
 
                 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
-                pm_node_t *constant = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);
+                constant_path = (pm_node_t *) pm_constant_path_node_create(parser, constant_path, &double_colon, &parser->previous);
-
-                constant_path = (pm_node_t *) pm_constant_path_node_create(parser, constant_path, &double_colon, constant);
             }
 
             // Here we retrieve the name of the module. If it wasn't a constant,
@@ -20442,8 +20440,7 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                         path = (pm_node_t *) pm_call_node_call_create(parser, node, &delimiter, &message, &arguments);
                     } else {
                         // Otherwise, this is a constant path. That would look like Foo::Bar.
-                        pm_node_t *child = (pm_node_t *) pm_constant_read_node_create(parser, &parser->previous);
+                        path = (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
-                        path = (pm_node_t *)pm_constant_path_node_create(parser, node, &delimiter, child);
                     }
 
                     // If this is followed by a comma then it is a multiple assignment.
@@ -20482,9 +20479,8 @@ parse_expression_infix(pm_parser_t *parser, pm_node_t *node, pm_binding_power_t
                     return (pm_node_t *) pm_call_node_shorthand_create(parser, node, &delimiter, &arguments);
                 }
                 default: {
-                    pm_parser_err_token(parser, &delimiter, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
+                    expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
-                    pm_node_t *child = (pm_node_t *) pm_missing_node_create(parser, delimiter.start, delimiter.end);
+                    return (pm_node_t *) pm_constant_path_node_create(parser, node, &delimiter, &parser->previous);
-                    return (pm_node_t *)pm_constant_path_node_create(parser, node, &delimiter, child);
                 }
             }
         }

test/prism/location_test.rb

@@ -298,7 +298,6 @@ module Prism
 
     def test_ConstantReadNode
       assert_location(ConstantReadNode, "Foo")
-      assert_location(ConstantReadNode, "Foo::Bar", 5...8, &:child)
     end
 
     def test_ConstantTargetNode

test/prism/snapshots/constants.txt

@@ -7,24 +7,21 @@
         │   ├── parent:
         │   │   @ ConstantReadNode (location: (1,0)-(1,1))
         │   │   └── name: :A
-        │   ├── child:
+        │   ├── name: :B
-        │   │   @ ConstantReadNode (location: (1,3)-(1,4))
+        │   ├── delimiter_loc: (1,1)-(1,3) = "::"
-        │   │   └── name: :B
+        │   └── name_loc: (1,3)-(1,4) = "B"
-        │   └── delimiter_loc: (1,1)-(1,3) = "::"
         ├── @ ConstantPathNode (location: (3,0)-(3,7))
         │   ├── parent:
         │   │   @ ConstantPathNode (location: (3,0)-(3,4))
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (3,0)-(3,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (3,3)-(3,4))
+        │   │   ├── delimiter_loc: (3,1)-(3,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (3,3)-(3,4) = "B"
-        │   │   └── delimiter_loc: (3,1)-(3,3) = "::"
+        │   ├── name: :C
-        │   ├── child:
+        │   ├── delimiter_loc: (3,4)-(3,6) = "::"
-        │   │   @ ConstantReadNode (location: (3,6)-(3,7))
+        │   └── name_loc: (3,6)-(3,7) = "C"
-        │   │   └── name: :C
-        │   └── delimiter_loc: (3,4)-(3,6) = "::"
         ├── @ ConstantPathNode (location: (5,0)-(5,4))
         │   ├── parent:
         │   │   @ CallNode (location: (5,0)-(5,1))
@@ -37,20 +34,18 @@
         │   │   ├── arguments: ∅
         │   │   ├── closing_loc: ∅
         │   │   └── block: ∅
-        │   ├── child:
+        │   ├── name: :B
-        │   │   @ ConstantReadNode (location: (5,3)-(5,4))
+        │   ├── delimiter_loc: (5,1)-(5,3) = "::"
-        │   │   └── name: :B
+        │   └── name_loc: (5,3)-(5,4) = "B"
-        │   └── delimiter_loc: (5,1)-(5,3) = "::"
         ├── @ ConstantPathWriteNode (location: (7,0)-(7,8))
         │   ├── target:
         │   │   @ ConstantPathNode (location: (7,0)-(7,4))
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (7,0)-(7,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (7,3)-(7,4))
+        │   │   ├── delimiter_loc: (7,1)-(7,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (7,3)-(7,4) = "B"
-        │   │   └── delimiter_loc: (7,1)-(7,3) = "::"
         │   ├── operator_loc: (7,5)-(7,6) = "="
         │   └── value:
         │       @ IntegerNode (location: (7,7)-(7,8))
@@ -249,10 +244,9 @@
         │   ├── receiver:
         │   │   @ ConstantPathNode (location: (27,0)-(27,3))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (27,2)-(27,3))
+        │   │   ├── delimiter_loc: (27,0)-(27,2) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (27,2)-(27,3) = "A"
-        │   │   └── delimiter_loc: (27,0)-(27,2) = "::"
         │   ├── call_operator_loc: (27,3)-(27,5) = "::"
         │   ├── name: :foo
         │   ├── message_loc: (27,5)-(27,8) = "foo"
@@ -264,10 +258,9 @@
         │   ├── target:
         │   │   @ ConstantPathNode (location: (29,0)-(29,3))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (29,2)-(29,3))
+        │   │   ├── delimiter_loc: (29,0)-(29,2) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (29,2)-(29,3) = "A"
-        │   │   └── delimiter_loc: (29,0)-(29,2) = "::"
         │   ├── operator_loc: (29,4)-(29,5) = "="
         │   └── value:
         │       @ IntegerNode (location: (29,6)-(29,7))
@@ -279,14 +272,12 @@
         │   │   ├── parent:
         │   │   │   @ ConstantPathNode (location: (31,0)-(31,3))
         │   │   │   ├── parent: ∅
-        │   │   │   ├── child:
+        │   │   │   ├── name: :A
-        │   │   │   │   @ ConstantReadNode (location: (31,2)-(31,3))
+        │   │   │   ├── delimiter_loc: (31,0)-(31,2) = "::"
-        │   │   │   │   └── name: :A
+        │   │   │   └── name_loc: (31,2)-(31,3) = "A"
-        │   │   │   └── delimiter_loc: (31,0)-(31,2) = "::"
+        │   │   ├── name: :B
-        │   │   ├── child:
+        │   │   ├── delimiter_loc: (31,3)-(31,5) = "::"
-        │   │   │   @ ConstantReadNode (location: (31,5)-(31,6))
+        │   │   └── name_loc: (31,5)-(31,6) = "B"
-        │   │   │   └── name: :B
-        │   │   └── delimiter_loc: (31,3)-(31,5) = "::"
         │   ├── operator_loc: (31,7)-(31,8) = "="
         │   └── value:
         │       @ IntegerNode (location: (31,9)-(31,10))
@@ -296,20 +287,17 @@
         │   ├── parent:
         │   │   @ ConstantPathNode (location: (33,0)-(33,3))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (33,2)-(33,3))
+        │   │   ├── delimiter_loc: (33,0)-(33,2) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (33,2)-(33,3) = "A"
-        │   │   └── delimiter_loc: (33,0)-(33,2) = "::"
+        │   ├── name: :B
-        │   ├── child:
+        │   ├── delimiter_loc: (33,3)-(33,5) = "::"
-        │   │   @ ConstantReadNode (location: (33,5)-(33,6))
+        │   └── name_loc: (33,5)-(33,6) = "B"
-        │   │   └── name: :B
-        │   └── delimiter_loc: (33,3)-(33,5) = "::"
         ├── @ ConstantPathNode (location: (35,0)-(35,3))
         │   ├── parent: ∅
-        │   ├── child:
+        │   ├── name: :A
-        │   │   @ ConstantReadNode (location: (35,2)-(35,3))
+        │   ├── delimiter_loc: (35,0)-(35,2) = "::"
-        │   │   └── name: :A
+        │   └── name_loc: (35,2)-(35,3) = "A"
-        │   └── delimiter_loc: (35,0)-(35,2) = "::"
         ├── @ CallNode (location: (37,0)-(37,8))
         │   ├── flags: ∅
         │   ├── receiver:
@@ -329,10 +317,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (39,0)-(39,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (39,3)-(39,4))
+        │   │   ├── delimiter_loc: (39,1)-(39,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (39,3)-(39,4) = "B"
-        │   │   └── delimiter_loc: (39,1)-(39,3) = "::"
         │   ├── call_operator_loc: (39,4)-(39,6) = "::"
         │   ├── name: :true
         │   ├── message_loc: (39,6)-(39,10) = "true"
@@ -488,10 +475,9 @@
         │   ├── parent:
         │   │   @ ConstantReadNode (location: (65,0)-(65,1))
         │   │   └── name: :A
-        │   ├── child:
+        │   ├── name: :C
-        │   │   @ ConstantReadNode (location: (67,0)-(67,1))
+        │   ├── delimiter_loc: (65,1)-(65,3) = "::"
-        │   │   └── name: :C
+        │   └── name_loc: (67,0)-(67,1) = "C"
-        │   └── delimiter_loc: (65,1)-(65,3) = "::"
         ├── @ CallNode (location: (69,0)-(69,8))
         │   ├── flags: ∅
         │   ├── receiver:
@@ -532,10 +518,9 @@
         │   ├── parent:
         │   │   @ ConstantReadNode (location: (75,0)-(75,1))
         │   │   └── name: :A
-        │   ├── child:
+        │   ├── name: :BEGIN
-        │   │   @ ConstantReadNode (location: (75,3)-(75,8))
+        │   ├── delimiter_loc: (75,1)-(75,3) = "::"
-        │   │   └── name: :BEGIN
+        │   └── name_loc: (75,3)-(75,8) = "BEGIN"
-        │   └── delimiter_loc: (75,1)-(75,3) = "::"
         ├── @ CallNode (location: (77,0)-(77,8))
         │   ├── flags: ∅
         │   ├── receiver:
@@ -636,10 +621,9 @@
         │   ├── parent:
         │   │   @ ConstantReadNode (location: (93,0)-(93,1))
         │   │   └── name: :A
-        │   ├── child:
+        │   ├── name: :END
-        │   │   @ ConstantReadNode (location: (93,3)-(93,6))
+        │   ├── delimiter_loc: (93,1)-(93,3) = "::"
-        │   │   └── name: :END
+        │   └── name_loc: (93,3)-(93,6) = "END"
-        │   └── delimiter_loc: (93,1)-(93,3) = "::"
         ├── @ CallNode (location: (95,0)-(95,9))
         │   ├── flags: ∅
         │   ├── receiver:
@@ -1207,10 +1191,9 @@
         │   │   ├── arguments: ∅
         │   │   ├── closing_loc: ∅
         │   │   └── block: ∅
-        │   ├── child:
+        │   ├── name: :C
-        │   │   @ ConstantReadNode (location: (180,0)-(180,1))
+        │   ├── delimiter_loc: (179,4)-(179,6) = "::"
-        │   │   └── name: :C
+        │   └── name_loc: (180,0)-(180,1) = "C"
-        │   └── delimiter_loc: (179,4)-(179,6) = "::"
         └── @ RangeNode (location: (182,0)-(184,10))
             ├── flags: ∅
             ├── left:

test/prism/snapshots/method_calls.txt

@@ -1443,10 +1443,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (97,0)-(97,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (97,3)-(97,4))
+        │   │   ├── delimiter_loc: (97,1)-(97,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (97,3)-(97,4) = "B"
-        │   │   └── delimiter_loc: (97,1)-(97,3) = "::"
         │   ├── call_operator_loc: (97,4)-(97,6) = "::"
         │   ├── name: :C
         │   ├── message_loc: (97,6)-(97,7) = "C"
@@ -1470,10 +1469,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (99,0)-(99,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (99,3)-(99,4))
+        │   │   ├── delimiter_loc: (99,1)-(99,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (99,3)-(99,4) = "B"
-        │   │   └── delimiter_loc: (99,1)-(99,3) = "::"
         │   ├── call_operator_loc: (99,4)-(99,6) = "::"
         │   ├── name: :C
         │   ├── message_loc: (99,6)-(99,7) = "C"
@@ -1497,10 +1495,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (101,0)-(101,1))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (101,3)-(101,4))
+        │   │   ├── delimiter_loc: (101,1)-(101,3) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (101,3)-(101,4) = "B"
-        │   │   └── delimiter_loc: (101,1)-(101,3) = "::"
         │   ├── call_operator_loc: (101,4)-(101,6) = "::"
         │   ├── name: :C
         │   ├── message_loc: (101,6)-(101,7) = "C"

test/prism/snapshots/modules.txt

@@ -72,10 +72,9 @@
         │   │   │   ├── arguments: ∅
         │   │   │   ├── closing_loc: ∅
         │   │   │   └── block: ∅
-        │   │   ├── child:
+        │   │   ├── name: :M
-        │   │   │   @ ConstantReadNode (location: (5,10)-(5,11))
+        │   │   ├── delimiter_loc: (5,8)-(5,10) = "::"
-        │   │   │   └── name: :M
+        │   │   └── name_loc: (5,10)-(5,11) = "M"
-        │   │   └── delimiter_loc: (5,8)-(5,10) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (6,0)-(6,3) = "end"
         │   └── name: :M
@@ -119,10 +118,9 @@
         │   ├── constant_path:
         │   │   @ ConstantPathNode (location: (11,7)-(11,10))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (11,9)-(11,10))
+        │   │   ├── delimiter_loc: (11,7)-(11,9) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (11,9)-(11,10) = "A"
-        │   │   └── delimiter_loc: (11,7)-(11,9) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (12,0)-(12,3) = "end"
         │   └── name: :A
@@ -144,10 +142,9 @@
         │   │   │   ├── arguments: ∅
         │   │   │   ├── closing_loc: (14,9)-(14,10) = "]"
         │   │   │   └── block: ∅
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (14,12)-(14,13))
+        │   │   ├── delimiter_loc: (14,10)-(14,12) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (14,12)-(14,13) = "B"
-        │   │   └── delimiter_loc: (14,10)-(14,12) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (15,0)-(15,3) = "end"
         │   └── name: :B
@@ -175,10 +172,9 @@
             │   │   │           └── value: 1
             │   │   ├── closing_loc: (17,10)-(17,11) = "]"
             │   │   └── block: ∅
-            │   ├── child:
+            │   ├── name: :B
-            │   │   @ ConstantReadNode (location: (17,13)-(17,14))
+            │   ├── delimiter_loc: (17,11)-(17,13) = "::"
-            │   │   └── name: :B
+            │   └── name_loc: (17,13)-(17,14) = "B"
-            │   └── delimiter_loc: (17,11)-(17,13) = "::"
             ├── body: ∅
             ├── end_keyword_loc: (18,0)-(18,3) = "end"
             └── name: :B

test/prism/snapshots/patterns.txt

@@ -1454,14 +1454,12 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantReadNode (location: (64,7)-(64,10))
         │   │   │   │   └── name: :Foo
-        │   │   │   ├── child:
+        │   │   │   ├── name: :Bar
-        │   │   │   │   @ ConstantReadNode (location: (64,12)-(64,15))
+        │   │   │   ├── delimiter_loc: (64,10)-(64,12) = "::"
-        │   │   │   │   └── name: :Bar
+        │   │   │   └── name_loc: (64,12)-(64,15) = "Bar"
-        │   │   │   └── delimiter_loc: (64,10)-(64,12) = "::"
+        │   │   ├── name: :Baz
-        │   │   ├── child:
+        │   │   ├── delimiter_loc: (64,15)-(64,17) = "::"
-        │   │   │   @ ConstantReadNode (location: (64,17)-(64,20))
+        │   │   └── name_loc: (64,17)-(64,20) = "Baz"
-        │   │   │   └── name: :Baz
-        │   │   └── delimiter_loc: (64,15)-(64,17) = "::"
         │   └── operator_loc: (64,4)-(64,6) = "=>"
         ├── @ MatchRequiredNode (location: (65,0)-(65,12))
         │   ├── value:
@@ -1478,10 +1476,9 @@
         │   ├── pattern:
         │   │   @ ConstantPathNode (location: (65,7)-(65,12))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :Foo
-        │   │   │   @ ConstantReadNode (location: (65,9)-(65,12))
+        │   │   ├── delimiter_loc: (65,7)-(65,9) = "::"
-        │   │   │   └── name: :Foo
+        │   │   └── name_loc: (65,9)-(65,12) = "Foo"
-        │   │   └── delimiter_loc: (65,7)-(65,9) = "::"
         │   └── operator_loc: (65,4)-(65,6) = "=>"
         ├── @ MatchRequiredNode (location: (66,0)-(66,22))
         │   ├── value:
@@ -1502,18 +1499,15 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantPathNode (location: (66,7)-(66,12))
         │   │   │   │   ├── parent: ∅
-        │   │   │   │   ├── child:
+        │   │   │   │   ├── name: :Foo
-        │   │   │   │   │   @ ConstantReadNode (location: (66,9)-(66,12))
+        │   │   │   │   ├── delimiter_loc: (66,7)-(66,9) = "::"
-        │   │   │   │   │   └── name: :Foo
+        │   │   │   │   └── name_loc: (66,9)-(66,12) = "Foo"
-        │   │   │   │   └── delimiter_loc: (66,7)-(66,9) = "::"
+        │   │   │   ├── name: :Bar
-        │   │   │   ├── child:
+        │   │   │   ├── delimiter_loc: (66,12)-(66,14) = "::"
-        │   │   │   │   @ ConstantReadNode (location: (66,14)-(66,17))
+        │   │   │   └── name_loc: (66,14)-(66,17) = "Bar"
-        │   │   │   │   └── name: :Bar
+        │   │   ├── name: :Baz
-        │   │   │   └── delimiter_loc: (66,12)-(66,14) = "::"
+        │   │   ├── delimiter_loc: (66,17)-(66,19) = "::"
-        │   │   ├── child:
+        │   │   └── name_loc: (66,19)-(66,22) = "Baz"
-        │   │   │   @ ConstantReadNode (location: (66,19)-(66,22))
-        │   │   │   └── name: :Baz
-        │   │   └── delimiter_loc: (66,17)-(66,19) = "::"
         │   └── operator_loc: (66,4)-(66,6) = "=>"
         ├── @ MatchRequiredNode (location: (68,0)-(68,12))
         │   ├── value:

test/prism/snapshots/seattlerb/case_in_86.txt

@@ -30,10 +30,9 @@
             │       │   ├── requireds: (length: 1)
             │       │   │   └── @ ConstantPathNode (location: (2,3)-(2,13))
             │       │   │       ├── parent: ∅
-            │       │   │       ├── child:
+            │       │   │       ├── name: :NilClass
-            │       │   │       │   @ ConstantReadNode (location: (2,5)-(2,13))
+            │       │   │       ├── delimiter_loc: (2,3)-(2,5) = "::"
-            │       │   │       │   └── name: :NilClass
+            │       │   │       └── name_loc: (2,5)-(2,13) = "NilClass"
-            │       │   │       └── delimiter_loc: (2,3)-(2,5) = "::"
             │       │   ├── rest:
             │       │   │   @ SplatNode (location: (2,15)-(2,16))
             │       │   │   ├── operator_loc: (2,15)-(2,16) = "*"

test/prism/snapshots/seattlerb/case_in_86_2.txt

@@ -35,10 +35,9 @@
             │       │   ├── posts: (length: 1)
             │       │   │   └── @ ConstantPathNode (location: (2,6)-(2,16))
             │       │   │       ├── parent: ∅
-            │       │   │       ├── child:
+            │       │   │       ├── name: :NilClass
-            │       │   │       │   @ ConstantReadNode (location: (2,8)-(2,16))
+            │       │   │       ├── delimiter_loc: (2,6)-(2,8) = "::"
-            │       │   │       │   └── name: :NilClass
+            │       │   │       └── name_loc: (2,8)-(2,16) = "NilClass"
-            │       │   │       └── delimiter_loc: (2,6)-(2,8) = "::"
             │       │   ├── opening_loc: ∅
             │       │   └── closing_loc: ∅
             │       ├── statements:

test/prism/snapshots/seattlerb/case_in_array_pat_const2.txt

@@ -20,10 +20,9 @@
             │       │   │   ├── parent:
             │       │   │   │   @ ConstantReadNode (location: (2,3)-(2,4))
             │       │   │   │   └── name: :B
-            │       │   │   ├── child:
+            │       │   │   ├── name: :C
-            │       │   │   │   @ ConstantReadNode (location: (2,6)-(2,7))
+            │       │   │   ├── delimiter_loc: (2,4)-(2,6) = "::"
-            │       │   │   │   └── name: :C
+            │       │   │   └── name_loc: (2,6)-(2,7) = "C"
-            │       │   │   └── delimiter_loc: (2,4)-(2,6) = "::"
             │       │   ├── requireds: (length: 1)
             │       │   │   └── @ LocalVariableTargetNode (location: (2,8)-(2,9))
             │       │   │       ├── name: :d

test/prism/snapshots/seattlerb/case_in_multiple.txt

@@ -18,10 +18,9 @@
             │   │   │   ├── parent:
             │   │   │   │   @ ConstantReadNode (location: (2,3)-(2,4))
             │   │   │   │   └── name: :A
-            │   │   │   ├── child:
+            │   │   │   ├── name: :B
-            │   │   │   │   @ ConstantReadNode (location: (2,6)-(2,7))
+            │   │   │   ├── delimiter_loc: (2,4)-(2,6) = "::"
-            │   │   │   │   └── name: :B
+            │   │   │   └── name_loc: (2,6)-(2,7) = "B"
-            │   │   │   └── delimiter_loc: (2,4)-(2,6) = "::"
             │   │   ├── statements:
             │   │   │   @ StatementsNode (location: (3,2)-(3,4))
             │   │   │   └── body: (length: 1)
@@ -39,10 +38,9 @@
             │       │   ├── parent:
             │       │   │   @ ConstantReadNode (location: (4,3)-(4,4))
             │       │   │   └── name: :D
-            │       │   ├── child:
+            │       │   ├── name: :E
-            │       │   │   @ ConstantReadNode (location: (4,6)-(4,7))
+            │       │   ├── delimiter_loc: (4,4)-(4,6) = "::"
-            │       │   │   └── name: :E
+            │       │   └── name_loc: (4,6)-(4,7) = "E"
-            │       │   └── delimiter_loc: (4,4)-(4,6) = "::"
             │       ├── statements:
             │       │   @ StatementsNode (location: (5,2)-(5,4))
             │       │   └── body: (length: 1)

test/prism/snapshots/seattlerb/const_2_op_asgn_or2.txt

@@ -9,14 +9,12 @@
             │   ├── parent:
             │   │   @ ConstantPathNode (location: (1,0)-(1,3))
             │   │   ├── parent: ∅
-            │   │   ├── child:
+            │   │   ├── name: :X
-            │   │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+            │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   │   └── name: :X
+            │   │   └── name_loc: (1,2)-(1,3) = "X"
-            │   │   └── delimiter_loc: (1,0)-(1,2) = "::"
+            │   ├── name: :Y
-            │   ├── child:
+            │   ├── delimiter_loc: (1,3)-(1,5) = "::"
-            │   │   @ ConstantReadNode (location: (1,5)-(1,6))
+            │   └── name_loc: (1,5)-(1,6) = "Y"
-            │   │   └── name: :Y
-            │   └── delimiter_loc: (1,3)-(1,5) = "::"
             ├── operator_loc: (1,7)-(1,10) = "||="
             └── value:
                 @ IntegerNode (location: (1,11)-(1,12))

test/prism/snapshots/seattlerb/const_3_op_asgn_or.txt

@@ -7,10 +7,9 @@
             ├── target:
             │   @ ConstantPathNode (location: (1,0)-(1,3))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :X
-            │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   └── name: :X
+            │   └── name_loc: (1,2)-(1,3) = "X"
-            │   └── delimiter_loc: (1,0)-(1,2) = "::"
             ├── operator_loc: (1,4)-(1,7) = "||="
             └── value:
                 @ IntegerNode (location: (1,8)-(1,9))

test/prism/snapshots/seattlerb/const_op_asgn_and1.txt

@@ -7,10 +7,9 @@
             ├── target:
             │   @ ConstantPathNode (location: (1,0)-(1,3))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :X
-            │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   └── name: :X
+            │   └── name_loc: (1,2)-(1,3) = "X"
-            │   └── delimiter_loc: (1,0)-(1,2) = "::"
             ├── operator_loc: (1,4)-(1,6) = "&="
             ├── value:
             │   @ IntegerNode (location: (1,7)-(1,8))

test/prism/snapshots/seattlerb/const_op_asgn_and2.txt

@@ -7,10 +7,9 @@
             ├── target:
             │   @ ConstantPathNode (location: (1,0)-(1,3))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :X
-            │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   └── name: :X
+            │   └── name_loc: (1,2)-(1,3) = "X"
-            │   └── delimiter_loc: (1,0)-(1,2) = "::"
             ├── operator_loc: (1,4)-(1,7) = "&&="
             └── value:
                 @ IntegerNode (location: (1,8)-(1,9))

test/prism/snapshots/seattlerb/const_op_asgn_or.txt

@@ -9,10 +9,9 @@
             │   ├── parent:
             │   │   @ ConstantReadNode (location: (1,0)-(1,1))
             │   │   └── name: :X
-            │   ├── child:
+            │   ├── name: :Y
-            │   │   @ ConstantReadNode (location: (1,3)-(1,4))
+            │   ├── delimiter_loc: (1,1)-(1,3) = "::"
-            │   │   └── name: :Y
+            │   └── name_loc: (1,3)-(1,4) = "Y"
-            │   └── delimiter_loc: (1,1)-(1,3) = "::"
             ├── operator_loc: (1,5)-(1,8) = "||="
             └── value:
                 @ IntegerNode (location: (1,9)-(1,10))

test/prism/snapshots/seattlerb/masgn_colon2.txt

@@ -20,10 +20,9 @@
             │       │   ├── arguments: ∅
             │       │   ├── closing_loc: ∅
             │       │   └── block: ∅
-            │       ├── child:
+            │       ├── name: :C
-            │       │   @ ConstantReadNode (location: (1,6)-(1,7))
+            │       ├── delimiter_loc: (1,4)-(1,6) = "::"
-            │       │   └── name: :C
+            │       └── name_loc: (1,6)-(1,7) = "C"
-            │       └── delimiter_loc: (1,4)-(1,6) = "::"
             ├── rest: ∅
             ├── rights: (length: 0)
             ├── lparen_loc: ∅

test/prism/snapshots/seattlerb/masgn_colon3.txt

@@ -7,16 +7,14 @@
             ├── lefts: (length: 2)
             │   ├── @ ConstantPathTargetNode (location: (1,0)-(1,3))
             │   │   ├── parent: ∅
-            │   │   ├── child:
+            │   │   ├── name: :A
-            │   │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+            │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   │   └── name: :A
+            │   │   └── name_loc: (1,2)-(1,3) = "A"
-            │   │   └── delimiter_loc: (1,0)-(1,2) = "::"
             │   └── @ ConstantPathTargetNode (location: (1,5)-(1,8))
             │       ├── parent: ∅
-            │       ├── child:
+            │       ├── name: :B
-            │       │   @ ConstantReadNode (location: (1,7)-(1,8))
+            │       ├── delimiter_loc: (1,5)-(1,7) = "::"
-            │       │   └── name: :B
+            │       └── name_loc: (1,7)-(1,8) = "B"
-            │       └── delimiter_loc: (1,5)-(1,7) = "::"
             ├── rest: ∅
             ├── rights: (length: 0)
             ├── lparen_loc: ∅

test/prism/snapshots/seattlerb/messy_op_asgn_lineno.txt

@@ -24,10 +24,9 @@
             │           │           │   ├── parent:
             │           │           │   │   @ ConstantReadNode (location: (1,3)-(1,4))
             │           │           │   │   └── name: :B
-            │           │           │   ├── child:
+            │           │           │   ├── name: :C
-            │           │           │   │   @ ConstantReadNode (location: (1,6)-(1,7))
+            │           │           │   ├── delimiter_loc: (1,4)-(1,6) = "::"
-            │           │           │   │   └── name: :C
+            │           │           │   └── name_loc: (1,6)-(1,7) = "C"
-            │           │           │   └── delimiter_loc: (1,4)-(1,6) = "::"
             │           │           ├── operator_loc: (1,8)-(1,10) = "*="
             │           │           ├── value:
             │           │           │   @ CallNode (location: (1,11)-(1,14))

test/prism/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt

@@ -9,10 +9,9 @@
             │   ├── parent:
             │   │   @ ConstantReadNode (location: (1,0)-(1,1))
             │   │   └── name: :A
-            │   ├── child:
+            │   ├── name: :B
-            │   │   @ ConstantReadNode (location: (1,3)-(1,4))
+            │   ├── delimiter_loc: (1,1)-(1,3) = "::"
-            │   │   └── name: :B
+            │   └── name_loc: (1,3)-(1,4) = "B"
-            │   └── delimiter_loc: (1,1)-(1,3) = "::"
             ├── operator_loc: (1,5)-(1,7) = "*="
             ├── value:
             │   @ CallNode (location: (1,8)-(1,11))

test/prism/snapshots/unparser/corpus/literal/assignment.txt

@@ -469,18 +469,16 @@
         │   ├── target:
         │   │   @ ConstantPathNode (location: (18,0)-(18,5))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :Foo
-        │   │   │   @ ConstantReadNode (location: (18,2)-(18,5))
+        │   │   ├── delimiter_loc: (18,0)-(18,2) = "::"
-        │   │   │   └── name: :Foo
+        │   │   └── name_loc: (18,2)-(18,5) = "Foo"
-        │   │   └── delimiter_loc: (18,0)-(18,2) = "::"
         │   ├── operator_loc: (18,6)-(18,7) = "="
         │   └── value:
         │       @ ConstantPathNode (location: (18,8)-(18,13))
         │       ├── parent: ∅
-        │       ├── child:
+        │       ├── name: :Bar
-        │       │   @ ConstantReadNode (location: (18,10)-(18,13))
+        │       ├── delimiter_loc: (18,8)-(18,10) = "::"
-        │       │   └── name: :Bar
+        │       └── name_loc: (18,10)-(18,13) = "Bar"
-        │       └── delimiter_loc: (18,8)-(18,10) = "::"
         ├── @ ClassVariableWriteNode (location: (19,0)-(19,7))
         │   ├── name: :@@a
         │   ├── name_loc: (19,0)-(19,3) = "@@a"
@@ -513,14 +511,12 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantReadNode (location: (22,0)-(22,4))
         │   │   │   │   └── name: :Name
-        │   │   │   ├── child:
+        │   │   │   ├── name: :Spaced
-        │   │   │   │   @ ConstantReadNode (location: (22,6)-(22,12))
+        │   │   │   ├── delimiter_loc: (22,4)-(22,6) = "::"
-        │   │   │   │   └── name: :Spaced
+        │   │   │   └── name_loc: (22,6)-(22,12) = "Spaced"
-        │   │   │   └── delimiter_loc: (22,4)-(22,6) = "::"
+        │   │   ├── name: :CONST
-        │   │   ├── child:
+        │   │   ├── delimiter_loc: (22,12)-(22,14) = "::"
-        │   │   │   @ ConstantReadNode (location: (22,14)-(22,19))
+        │   │   └── name_loc: (22,14)-(22,19) = "CONST"
-        │   │   │   └── name: :CONST
-        │   │   └── delimiter_loc: (22,12)-(22,14) = "::"
         │   ├── operator_loc: (22,20)-(22,21) = "="
         │   └── value:
         │       @ IntegerNode (location: (22,22)-(22,23))

test/prism/snapshots/unparser/corpus/literal/class.txt

@@ -68,10 +68,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (11,6)-(11,7))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (11,9)-(11,10))
+        │   │   ├── delimiter_loc: (11,7)-(11,9) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (11,9)-(11,10) = "B"
-        │   │   └── delimiter_loc: (11,7)-(11,9) = "::"
         │   ├── inheritance_operator_loc: ∅
         │   ├── superclass: ∅
         │   ├── body: ∅
@@ -87,14 +86,12 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantReadNode (location: (14,6)-(14,7))
         │   │   │   │   └── name: :A
-        │   │   │   ├── child:
+        │   │   │   ├── name: :B
-        │   │   │   │   @ ConstantReadNode (location: (14,9)-(14,10))
+        │   │   │   ├── delimiter_loc: (14,7)-(14,9) = "::"
-        │   │   │   │   └── name: :B
+        │   │   │   └── name_loc: (14,9)-(14,10) = "B"
-        │   │   │   └── delimiter_loc: (14,7)-(14,9) = "::"
+        │   │   ├── name: :C
-        │   │   ├── child:
+        │   │   ├── delimiter_loc: (14,10)-(14,12) = "::"
-        │   │   │   @ ConstantReadNode (location: (14,12)-(14,13))
+        │   │   └── name_loc: (14,12)-(14,13) = "C"
-        │   │   │   └── name: :C
-        │   │   └── delimiter_loc: (14,10)-(14,12) = "::"
         │   ├── inheritance_operator_loc: ∅
         │   ├── superclass: ∅
         │   ├── body: ∅
@@ -125,10 +122,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (20,10)-(20,11))
         │   │   │   └── name: :B
-        │   │   ├── child:
+        │   │   ├── name: :C
-        │   │   │   @ ConstantReadNode (location: (20,13)-(20,14))
+        │   │   ├── delimiter_loc: (20,11)-(20,13) = "::"
-        │   │   │   └── name: :C
+        │   │   └── name_loc: (20,13)-(20,14) = "C"
-        │   │   └── delimiter_loc: (20,11)-(20,13) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (21,0)-(21,3) = "end"
         │   └── name: :A
@@ -140,20 +136,18 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (23,6)-(23,7))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (23,9)-(23,10))
+        │   │   ├── delimiter_loc: (23,7)-(23,9) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (23,9)-(23,10) = "B"
-        │   │   └── delimiter_loc: (23,7)-(23,9) = "::"
         │   ├── inheritance_operator_loc: (23,11)-(23,12) = "<"
         │   ├── superclass:
         │   │   @ ConstantPathNode (location: (23,13)-(23,17))
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (23,13)-(23,14))
         │   │   │   └── name: :C
-        │   │   ├── child:
+        │   │   ├── name: :D
-        │   │   │   @ ConstantReadNode (location: (23,16)-(23,17))
+        │   │   ├── delimiter_loc: (23,14)-(23,16) = "::"
-        │   │   │   └── name: :D
+        │   │   └── name_loc: (23,16)-(23,17) = "D"
-        │   │   └── delimiter_loc: (23,14)-(23,16) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (24,0)-(24,3) = "end"
         │   └── name: :B
@@ -222,10 +216,9 @@
             ├── constant_path:
             │   @ ConstantPathNode (location: (34,6)-(34,9))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :A
-            │   │   @ ConstantReadNode (location: (34,8)-(34,9))
+            │   ├── delimiter_loc: (34,6)-(34,8) = "::"
-            │   │   └── name: :A
+            │   └── name_loc: (34,8)-(34,9) = "A"
-            │   └── delimiter_loc: (34,6)-(34,8) = "::"
             ├── inheritance_operator_loc: ∅
             ├── superclass: ∅
             ├── body: ∅

test/prism/snapshots/unparser/corpus/literal/defs.txt

@@ -225,10 +225,9 @@
         │   │   │   │   ├── parent:
         │   │   │   │   │   @ ConstantReadNode (location: (26,5)-(26,8))
         │   │   │   │   │   └── name: :Foo
-        │   │   │   │   ├── child:
+        │   │   │   │   ├── name: :Bar
-        │   │   │   │   │   @ ConstantReadNode (location: (26,10)-(26,13))
+        │   │   │   │   ├── delimiter_loc: (26,8)-(26,10) = "::"
-        │   │   │   │   │   └── name: :Bar
+        │   │   │   │   └── name_loc: (26,10)-(26,13) = "Bar"
-        │   │   │   │   └── delimiter_loc: (26,8)-(26,10) = "::"
         │   │   │   ├── call_operator_loc: (26,13)-(26,14) = "."
         │   │   │   ├── name: :baz
         │   │   │   ├── message_loc: (26,14)-(26,17) = "baz"
@@ -269,10 +268,9 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantReadNode (location: (30,5)-(30,8))
         │   │   │   │   └── name: :Foo
-        │   │   │   ├── child:
+        │   │   │   ├── name: :Bar
-        │   │   │   │   @ ConstantReadNode (location: (30,10)-(30,13))
+        │   │   │   ├── delimiter_loc: (30,8)-(30,10) = "::"
-        │   │   │   │   └── name: :Bar
+        │   │   │   └── name_loc: (30,10)-(30,13) = "Bar"
-        │   │   │   └── delimiter_loc: (30,8)-(30,10) = "::"
         │   │   ├── opening_loc: (30,4)-(30,5) = "("
         │   │   └── closing_loc: (30,13)-(30,14) = ")"
         │   ├── parameters: ∅

test/prism/snapshots/unparser/corpus/literal/module.txt

@@ -20,10 +20,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (4,7)-(4,8))
         │   │   │   └── name: :A
-        │   │   ├── child:
+        │   │   ├── name: :B
-        │   │   │   @ ConstantReadNode (location: (4,10)-(4,11))
+        │   │   ├── delimiter_loc: (4,8)-(4,10) = "::"
-        │   │   │   └── name: :B
+        │   │   └── name_loc: (4,10)-(4,11) = "B"
-        │   │   └── delimiter_loc: (4,8)-(4,10) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (5,0)-(5,3) = "end"
         │   └── name: :B
@@ -37,14 +36,12 @@
         │   │   │   ├── parent:
         │   │   │   │   @ ConstantReadNode (location: (7,7)-(7,8))
         │   │   │   │   └── name: :A
-        │   │   │   ├── child:
+        │   │   │   ├── name: :B
-        │   │   │   │   @ ConstantReadNode (location: (7,10)-(7,11))
+        │   │   │   ├── delimiter_loc: (7,8)-(7,10) = "::"
-        │   │   │   │   └── name: :B
+        │   │   │   └── name_loc: (7,10)-(7,11) = "B"
-        │   │   │   └── delimiter_loc: (7,8)-(7,10) = "::"
+        │   │   ├── name: :C
-        │   │   ├── child:
+        │   │   ├── delimiter_loc: (7,11)-(7,13) = "::"
-        │   │   │   @ ConstantReadNode (location: (7,13)-(7,14))
+        │   │   └── name_loc: (7,13)-(7,14) = "C"
-        │   │   │   └── name: :C
-        │   │   └── delimiter_loc: (7,11)-(7,13) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (8,0)-(8,3) = "end"
         │   └── name: :C

test/prism/snapshots/unparser/corpus/literal/variables.txt

@@ -29,25 +29,21 @@
         │   ├── parent:
         │   │   @ ConstantReadNode (location: (8,0)-(8,6))
         │   │   └── name: :SCOPED
-        │   ├── child:
+        │   ├── name: :CONST
-        │   │   @ ConstantReadNode (location: (8,8)-(8,13))
+        │   ├── delimiter_loc: (8,6)-(8,8) = "::"
-        │   │   └── name: :CONST
+        │   └── name_loc: (8,8)-(8,13) = "CONST"
-        │   └── delimiter_loc: (8,6)-(8,8) = "::"
         ├── @ ConstantPathNode (location: (9,0)-(9,10))
         │   ├── parent: ∅
-        │   ├── child:
+        │   ├── name: :TOPLEVEL
-        │   │   @ ConstantReadNode (location: (9,2)-(9,10))
+        │   ├── delimiter_loc: (9,0)-(9,2) = "::"
-        │   │   └── name: :TOPLEVEL
+        │   └── name_loc: (9,2)-(9,10) = "TOPLEVEL"
-        │   └── delimiter_loc: (9,0)-(9,2) = "::"
         └── @ ConstantPathNode (location: (10,0)-(10,17))
             ├── parent:
             │   @ ConstantPathNode (location: (10,0)-(10,10))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :TOPLEVEL
-            │   │   @ ConstantReadNode (location: (10,2)-(10,10))
+            │   ├── delimiter_loc: (10,0)-(10,2) = "::"
-            │   │   └── name: :TOPLEVEL
+            │   └── name_loc: (10,2)-(10,10) = "TOPLEVEL"
-            │   └── delimiter_loc: (10,0)-(10,2) = "::"
+            ├── name: :CONST
-            ├── child:
+            ├── delimiter_loc: (10,10)-(10,12) = "::"
-            │   @ ConstantReadNode (location: (10,12)-(10,17))
+            └── name_loc: (10,12)-(10,17) = "CONST"
-            │   └── name: :CONST
-            └── delimiter_loc: (10,10)-(10,12) = "::"

test/prism/snapshots/whitequark/casgn_scoped.txt

@@ -9,10 +9,9 @@
             │   ├── parent:
             │   │   @ ConstantReadNode (location: (1,0)-(1,3))
             │   │   └── name: :Bar
-            │   ├── child:
+            │   ├── name: :Foo
-            │   │   @ ConstantReadNode (location: (1,5)-(1,8))
+            │   ├── delimiter_loc: (1,3)-(1,5) = "::"
-            │   │   └── name: :Foo
+            │   └── name_loc: (1,5)-(1,8) = "Foo"
-            │   └── delimiter_loc: (1,3)-(1,5) = "::"
             ├── operator_loc: (1,9)-(1,10) = "="
             └── value:
                 @ IntegerNode (location: (1,11)-(1,13))

test/prism/snapshots/whitequark/casgn_toplevel.txt

@@ -7,10 +7,9 @@
             ├── target:
             │   @ ConstantPathNode (location: (1,0)-(1,5))
             │   ├── parent: ∅
-            │   ├── child:
+            │   ├── name: :Foo
-            │   │   @ ConstantReadNode (location: (1,2)-(1,5))
+            │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   │   └── name: :Foo
+            │   └── name_loc: (1,2)-(1,5) = "Foo"
-            │   └── delimiter_loc: (1,0)-(1,2) = "::"
             ├── operator_loc: (1,6)-(1,7) = "="
             └── value:
                 @ IntegerNode (location: (1,8)-(1,10))

test/prism/snapshots/whitequark/const_op_asgn.txt

@@ -7,10 +7,9 @@
         │   ├── target:
         │   │   @ ConstantPathNode (location: (1,0)-(1,3))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+        │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (1,2)-(1,3) = "A"
-        │   │   └── delimiter_loc: (1,0)-(1,2) = "::"
         │   ├── operator_loc: (1,4)-(1,6) = "+="
         │   ├── value:
         │   │   @ IntegerNode (location: (1,7)-(1,8))
@@ -32,10 +31,9 @@
         │   │   ├── parent:
         │   │   │   @ ConstantReadNode (location: (5,0)-(5,1))
         │   │   │   └── name: :B
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (5,3)-(5,4))
+        │   │   ├── delimiter_loc: (5,1)-(5,3) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (5,3)-(5,4) = "A"
-        │   │   └── delimiter_loc: (5,1)-(5,3) = "::"
         │   ├── operator_loc: (5,5)-(5,7) = "+="
         │   ├── value:
         │   │   @ IntegerNode (location: (5,8)-(5,9))
@@ -54,10 +52,9 @@
         │   │           ├── target:
         │   │           │   @ ConstantPathNode (location: (7,7)-(7,10))
         │   │           │   ├── parent: ∅
-        │   │           │   ├── child:
+        │   │           │   ├── name: :A
-        │   │           │   │   @ ConstantReadNode (location: (7,9)-(7,10))
+        │   │           │   ├── delimiter_loc: (7,7)-(7,9) = "::"
-        │   │           │   │   └── name: :A
+        │   │           │   └── name_loc: (7,9)-(7,10) = "A"
-        │   │           │   └── delimiter_loc: (7,7)-(7,9) = "::"
         │   │           ├── operator_loc: (7,11)-(7,14) = "||="
         │   │           └── value:
         │   │               @ IntegerNode (location: (7,15)-(7,16))
@@ -83,10 +80,9 @@
             │           │   @ ConstantPathNode (location: (9,7)-(9,14))
             │           │   ├── parent:
             │           │   │   @ SelfNode (location: (9,7)-(9,11))
-            │           │   ├── child:
+            │           │   ├── name: :A
-            │           │   │   @ ConstantReadNode (location: (9,13)-(9,14))
+            │           │   ├── delimiter_loc: (9,11)-(9,13) = "::"
-            │           │   │   └── name: :A
+            │           │   └── name_loc: (9,13)-(9,14) = "A"
-            │           │   └── delimiter_loc: (9,11)-(9,13) = "::"
             │           ├── operator_loc: (9,15)-(9,18) = "||="
             │           └── value:
             │               @ IntegerNode (location: (9,19)-(9,20))

test/prism/snapshots/whitequark/const_scoped.txt

@@ -7,7 +7,6 @@
             ├── parent:
             │   @ ConstantReadNode (location: (1,0)-(1,3))
             │   └── name: :Bar
-            ├── child:
+            ├── name: :Foo
-            │   @ ConstantReadNode (location: (1,5)-(1,8))
+            ├── delimiter_loc: (1,3)-(1,5) = "::"
-            │   └── name: :Foo
+            └── name_loc: (1,5)-(1,8) = "Foo"
-            └── delimiter_loc: (1,3)-(1,5) = "::"

test/prism/snapshots/whitequark/const_toplevel.txt

@@ -5,7 +5,6 @@
     └── body: (length: 1)
         └── @ ConstantPathNode (location: (1,0)-(1,5))
             ├── parent: ∅
-            ├── child:
+            ├── name: :Foo
-            │   @ ConstantReadNode (location: (1,2)-(1,5))
+            ├── delimiter_loc: (1,0)-(1,2) = "::"
-            │   └── name: :Foo
+            └── name_loc: (1,2)-(1,5) = "Foo"
-            └── delimiter_loc: (1,0)-(1,2) = "::"

test/prism/snapshots/whitequark/cpath.txt

@@ -9,10 +9,9 @@
         │   ├── constant_path:
         │   │   @ ConstantPathNode (location: (1,7)-(1,12))
         │   │   ├── parent: ∅
-        │   │   ├── child:
+        │   │   ├── name: :Foo
-        │   │   │   @ ConstantReadNode (location: (1,9)-(1,12))
+        │   │   ├── delimiter_loc: (1,7)-(1,9) = "::"
-        │   │   │   └── name: :Foo
+        │   │   └── name_loc: (1,9)-(1,12) = "Foo"
-        │   │   └── delimiter_loc: (1,7)-(1,9) = "::"
         │   ├── body: ∅
         │   ├── end_keyword_loc: (1,14)-(1,17) = "end"
         │   └── name: :Foo
@@ -24,10 +23,9 @@
             │   ├── parent:
             │   │   @ ConstantReadNode (location: (3,7)-(3,10))
             │   │   └── name: :Bar
-            │   ├── child:
+            │   ├── name: :Foo
-            │   │   @ ConstantReadNode (location: (3,12)-(3,15))
+            │   ├── delimiter_loc: (3,10)-(3,12) = "::"
-            │   │   └── name: :Foo
+            │   └── name_loc: (3,12)-(3,15) = "Foo"
-            │   └── delimiter_loc: (3,10)-(3,12) = "::"
             ├── body: ∅
             ├── end_keyword_loc: (3,17)-(3,20) = "end"
             └── name: :Foo

test/prism/snapshots/whitequark/masgn_const.txt

@@ -7,10 +7,9 @@
         │   ├── lefts: (length: 2)
         │   │   ├── @ ConstantPathTargetNode (location: (1,0)-(1,3))
         │   │   │   ├── parent: ∅
-        │   │   │   ├── child:
+        │   │   │   ├── name: :A
-        │   │   │   │   @ ConstantReadNode (location: (1,2)-(1,3))
+        │   │   │   ├── delimiter_loc: (1,0)-(1,2) = "::"
-        │   │   │   │   └── name: :A
+        │   │   │   └── name_loc: (1,2)-(1,3) = "A"
-        │   │   │   └── delimiter_loc: (1,0)-(1,2) = "::"
         │   │   └── @ LocalVariableTargetNode (location: (1,5)-(1,8))
         │   │       ├── name: :foo
         │   │       └── depth: 0
@@ -28,10 +27,9 @@
             │   ├── @ ConstantPathTargetNode (location: (3,0)-(3,7))
             │   │   ├── parent:
             │   │   │   @ SelfNode (location: (3,0)-(3,4))
-            │   │   ├── child:
+            │   │   ├── name: :A
-            │   │   │   @ ConstantReadNode (location: (3,6)-(3,7))
+            │   │   ├── delimiter_loc: (3,4)-(3,6) = "::"
-            │   │   │   └── name: :A
+            │   │   └── name_loc: (3,6)-(3,7) = "A"
-            │   │   └── delimiter_loc: (3,4)-(3,6) = "::"
             │   └── @ LocalVariableTargetNode (location: (3,9)-(3,12))
             │       ├── name: :foo
             │       └── depth: 0

test/prism/snapshots/whitequark/op_asgn_cmd.txt

@@ -103,10 +103,9 @@
         │   │   │   ├── arguments: ∅
         │   │   │   ├── closing_loc: ∅
         │   │   │   └── block: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (5,5)-(5,6))
+        │   │   ├── delimiter_loc: (5,3)-(5,5) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (5,5)-(5,6) = "A"
-        │   │   └── delimiter_loc: (5,3)-(5,5) = "::"
         │   ├── operator_loc: (5,7)-(5,9) = "+="
         │   ├── value:
         │   │   @ CallNode (location: (5,10)-(5,15))

test/prism/snapshots/whitequark/ruby_bug_12073.txt

@@ -75,10 +75,9 @@
             │           │       │   ├── parent:
             │           │       │   │   @ ConstantReadNode (location: (3,21)-(3,22))
             │           │       │   │   └── name: :A
-            │           │       │   ├── child:
+            │           │       │   ├── name: :B
-            │           │       │   │   @ ConstantReadNode (location: (3,24)-(3,25))
+            │           │       │   ├── delimiter_loc: (3,22)-(3,24) = "::"
-            │           │       │   │   └── name: :B
+            │           │       │   └── name_loc: (3,24)-(3,25) = "B"
-            │           │       │   └── delimiter_loc: (3,22)-(3,24) = "::"
             │           │       └── @ StringNode (location: (3,27)-(3,29))
             │           │           ├── flags: ∅
             │           │           ├── opening_loc: (3,27)-(3,28) = "'"

test/prism/snapshots/whitequark/ruby_bug_12402.txt

@@ -312,10 +312,9 @@
         │   │   │   @ LocalVariableReadNode (location: (17,0)-(17,3))
         │   │   │   ├── name: :foo
         │   │   │   └── depth: 0
-        │   │   ├── child:
+        │   │   ├── name: :C
-        │   │   │   @ ConstantReadNode (location: (17,5)-(17,6))
+        │   │   ├── delimiter_loc: (17,3)-(17,5) = "::"
-        │   │   │   └── name: :C
+        │   │   └── name_loc: (17,5)-(17,6) = "C"
-        │   │   └── delimiter_loc: (17,3)-(17,5) = "::"
         │   ├── operator_loc: (17,7)-(17,10) = "||="
         │   └── value:
         │       @ RescueModifierNode (location: (17,11)-(17,31))
@@ -353,10 +352,9 @@
         │   │   │   @ LocalVariableReadNode (location: (19,0)-(19,3))
         │   │   │   ├── name: :foo
         │   │   │   └── depth: 0
-        │   │   ├── child:
+        │   │   ├── name: :C
-        │   │   │   @ ConstantReadNode (location: (19,5)-(19,6))
+        │   │   ├── delimiter_loc: (19,3)-(19,5) = "::"
-        │   │   │   └── name: :C
+        │   │   └── name_loc: (19,5)-(19,6) = "C"
-        │   │   └── delimiter_loc: (19,3)-(19,5) = "::"
         │   ├── operator_loc: (19,7)-(19,10) = "||="
         │   └── value:
         │       @ RescueModifierNode (location: (19,11)-(19,32))

test/prism/snapshots/whitequark/send_attr_asgn.txt

@@ -69,10 +69,9 @@
         │   │   │   ├── arguments: ∅
         │   │   │   ├── closing_loc: ∅
         │   │   │   └── block: ∅
-        │   │   ├── child:
+        │   │   ├── name: :A
-        │   │   │   @ ConstantReadNode (location: (5,5)-(5,6))
+        │   │   ├── delimiter_loc: (5,3)-(5,5) = "::"
-        │   │   │   └── name: :A
+        │   │   └── name_loc: (5,5)-(5,6) = "A"
-        │   │   └── delimiter_loc: (5,3)-(5,5) = "::"
         │   ├── operator_loc: (5,7)-(5,8) = "="
         │   └── value:
         │       @ IntegerNode (location: (5,9)-(5,10))