path: root/test/yarp/snapshots/constants.txt

@ ProgramNode (location: (0...792))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...792))
    └── body: (length: 90)
        ├── @ ConstantPathNode (location: (0...4))
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (0...1))
        │   │   └── name: :A
        │   ├── child:
        │   │   @ ConstantReadNode (location: (3...4))
        │   │   └── name: :B
        │   └── delimiter_loc: (1...3) = "::"
        ├── @ ConstantPathNode (location: (6...13))
        │   ├── parent:
        │   │   @ ConstantPathNode (location: (6...10))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (6...7))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (9...10))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (7...9) = "::"
        │   ├── child:
        │   │   @ ConstantReadNode (location: (12...13))
        │   │   └── name: :C
        │   └── delimiter_loc: (10...12) = "::"
        ├── @ ConstantPathNode (location: (15...19))
        │   ├── parent:
        │   │   @ CallNode (location: (15...16))
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── message_loc: (15...16) = "a"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: variable_call
        │   │   └── name: "a"
        │   ├── child:
        │   │   @ ConstantReadNode (location: (18...19))
        │   │   └── name: :B
        │   └── delimiter_loc: (16...18) = "::"
        ├── @ ConstantPathWriteNode (location: (21...29))
        │   ├── target:
        │   │   @ ConstantPathNode (location: (21...25))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (21...22))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (24...25))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (22...24) = "::"
        │   ├── operator_loc: (26...27) = "="
        │   └── value:
        │       @ IntegerNode (location: (28...29))
        │       └── flags: decimal
        ├── @ ConstantWriteNode (location: (31...36))
        │   ├── name: :A
        │   ├── name_loc: (31...32) = "A"
        │   ├── value:
        │   │   @ IntegerNode (location: (35...36))
        │   │   └── flags: decimal
        │   └── operator_loc: (33...34) = "="
        ├── @ ConstantReadNode (location: (38...41))
        │   └── name: :ABC
        ├── @ CallNode (location: (43...48))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (43...46) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (47...48))
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (47...48))
        │   │           └── flags: decimal
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "Foo"
        ├── @ CallNode (location: (50...58))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (50...53) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (54...58))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (54...58))
        │   │           ├── operator_loc: (54...55) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (55...58))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (55...58) = "bar"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "bar"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "Foo"
        ├── @ CallNode (location: (60...69))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (60...63) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (64...69))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (64...69))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (64...69))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (66...69))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (66...69) = "bar"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "bar"
        │   │                   └── operator_loc: (64...66) = "**"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "Foo"
        ├── @ CallNode (location: (71...79))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (71...74) = "Foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockArgumentNode (location: (75...79))
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (76...79))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (76...79) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "bar"
        │   │   └── operator_loc: (75...76) = "&"
        │   ├── flags: ∅
        │   └── name: "Foo"
        ├── @ CallNode (location: (81...94))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (81...84))
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (84...86) = "::"
        │   ├── message_loc: (86...89) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (90...94))
        │   │   └── arguments: (length: 1)
        │   │       └── @ SplatNode (location: (90...94))
        │   │           ├── operator_loc: (90...91) = "*"
        │   │           └── expression:
        │   │               @ CallNode (location: (91...94))
        │   │               ├── receiver: ∅
        │   │               ├── call_operator_loc: ∅
        │   │               ├── message_loc: (91...94) = "baz"
        │   │               ├── opening_loc: ∅
        │   │               ├── arguments: ∅
        │   │               ├── closing_loc: ∅
        │   │               ├── block: ∅
        │   │               ├── flags: variable_call
        │   │               └── name: "baz"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "Bar"
        ├── @ CallNode (location: (96...110))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (96...99))
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (99...101) = "::"
        │   ├── message_loc: (101...104) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (105...110))
        │   │   └── arguments: (length: 1)
        │   │       └── @ KeywordHashNode (location: (105...110))
        │   │           └── elements: (length: 1)
        │   │               └── @ AssocSplatNode (location: (105...110))
        │   │                   ├── value:
        │   │                   │   @ CallNode (location: (107...110))
        │   │                   │   ├── receiver: ∅
        │   │                   │   ├── call_operator_loc: ∅
        │   │                   │   ├── message_loc: (107...110) = "baz"
        │   │                   │   ├── opening_loc: ∅
        │   │                   │   ├── arguments: ∅
        │   │                   │   ├── closing_loc: ∅
        │   │                   │   ├── block: ∅
        │   │                   │   ├── flags: variable_call
        │   │                   │   └── name: "baz"
        │   │                   └── operator_loc: (105...107) = "**"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "Bar"
        ├── @ CallNode (location: (112...125))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (112...115))
        │   │   └── name: :Foo
        │   ├── call_operator_loc: (115...117) = "::"
        │   ├── message_loc: (117...120) = "Bar"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block:
        │   │   @ BlockArgumentNode (location: (121...125))
        │   │   ├── expression:
        │   │   │   @ CallNode (location: (122...125))
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (122...125) = "baz"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: variable_call
        │   │   │   └── name: "baz"
        │   │   └── operator_loc: (121...122) = "&"
        │   ├── flags: ∅
        │   └── name: "Bar"
        ├── @ CallNode (location: (127...135))
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (127...130))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (129...130))
        │   │   │   └── name: :A
        │   │   └── delimiter_loc: (127...129) = "::"
        │   ├── call_operator_loc: (130...132) = "::"
        │   ├── message_loc: (132...135) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ ConstantPathWriteNode (location: (137...144))
        │   ├── target:
        │   │   @ ConstantPathNode (location: (137...140))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (139...140))
        │   │   │   └── name: :A
        │   │   └── delimiter_loc: (137...139) = "::"
        │   ├── operator_loc: (141...142) = "="
        │   └── value:
        │       @ IntegerNode (location: (143...144))
        │       └── flags: decimal
        ├── @ ConstantPathWriteNode (location: (146...156))
        │   ├── target:
        │   │   @ ConstantPathNode (location: (146...152))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (146...149))
        │   │   │   ├── parent: ∅
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (148...149))
        │   │   │   │   └── name: :A
        │   │   │   └── delimiter_loc: (146...148) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (151...152))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (149...151) = "::"
        │   ├── operator_loc: (153...154) = "="
        │   └── value:
        │       @ IntegerNode (location: (155...156))
        │       └── flags: decimal
        ├── @ ConstantPathNode (location: (158...164))
        │   ├── parent:
        │   │   @ ConstantPathNode (location: (158...161))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (160...161))
        │   │   │   └── name: :A
        │   │   └── delimiter_loc: (158...160) = "::"
        │   ├── child:
        │   │   @ ConstantReadNode (location: (163...164))
        │   │   └── name: :B
        │   └── delimiter_loc: (161...163) = "::"
        ├── @ ConstantPathNode (location: (166...169))
        │   ├── parent: ∅
        │   ├── child:
        │   │   @ ConstantReadNode (location: (168...169))
        │   │   └── name: :A
        │   └── delimiter_loc: (166...168) = "::"
        ├── @ CallNode (location: (171...179))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (171...172))
        │   │   └── name: :A
        │   ├── call_operator_loc: (172...174) = "::"
        │   ├── message_loc: (174...179) = "false"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "false"
        ├── @ CallNode (location: (181...191))
        │   ├── receiver:
        │   │   @ ConstantPathNode (location: (181...185))
        │   │   ├── parent:
        │   │   │   @ ConstantReadNode (location: (181...182))
        │   │   │   └── name: :A
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (184...185))
        │   │   │   └── name: :B
        │   │   └── delimiter_loc: (182...184) = "::"
        │   ├── call_operator_loc: (185...187) = "::"
        │   ├── message_loc: (187...191) = "true"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "true"
        ├── @ CallNode (location: (193...197))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (193...194))
        │   │   └── name: :A
        │   ├── call_operator_loc: (194...196) = "::"
        │   ├── message_loc: (196...197) = "&"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "&"
        ├── @ CallNode (location: (199...203))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (199...200))
        │   │   └── name: :A
        │   ├── call_operator_loc: (200...202) = "::"
        │   ├── message_loc: (202...203) = "`"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "`"
        ├── @ CallNode (location: (205...209))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (205...206))
        │   │   └── name: :A
        │   ├── call_operator_loc: (206...208) = "::"
        │   ├── message_loc: (208...209) = "!"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "!"
        ├── @ CallNode (location: (211...216))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (211...212))
        │   │   └── name: :A
        │   ├── call_operator_loc: (212...214) = "::"
        │   ├── message_loc: (214...216) = "!="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "!="
        ├── @ CallNode (location: (218...222))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (218...219))
        │   │   └── name: :A
        │   ├── call_operator_loc: (219...221) = "::"
        │   ├── message_loc: (221...222) = "^"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "^"
        ├── @ CallNode (location: (224...229))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (224...225))
        │   │   └── name: :A
        │   ├── call_operator_loc: (225...227) = "::"
        │   ├── message_loc: (227...229) = "=="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=="
        ├── @ CallNode (location: (231...237))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (231...232))
        │   │   └── name: :A
        │   ├── call_operator_loc: (232...234) = "::"
        │   ├── message_loc: (234...237) = "==="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "==="
        ├── @ CallNode (location: (239...244))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (239...240))
        │   │   └── name: :A
        │   ├── call_operator_loc: (240...242) = "::"
        │   ├── message_loc: (242...244) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=~"
        ├── @ CallNode (location: (246...250))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (246...247))
        │   │   └── name: :A
        │   ├── call_operator_loc: (247...249) = "::"
        │   ├── message_loc: (249...250) = ">"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: ">"
        ├── @ CallNode (location: (252...257))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (252...253))
        │   │   └── name: :A
        │   ├── call_operator_loc: (253...255) = "::"
        │   ├── message_loc: (255...257) = ">="
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: ">="
        ├── @ CallNode (location: (259...264))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (259...260))
        │   │   └── name: :A
        │   ├── call_operator_loc: (260...262) = "::"
        │   ├── message_loc: (262...264) = ">>"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: ">>"
        ├── @ CallNode (location: (266...271))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (266...267))
        │   │   └── name: :A
        │   ├── call_operator_loc: (267...269) = "::"
        │   ├── message_loc: (269...271) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "<<"
        ├── @ ConstantPathNode (location: (273...281))
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (273...274))
        │   │   └── name: :A
        │   ├── child:
        │   │   @ ConstantReadNode (location: (280...281))
        │   │   └── name: :C
        │   └── delimiter_loc: (274...276) = "::"
        ├── @ CallNode (location: (283...291))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (283...284))
        │   │   └── name: :A
        │   ├── call_operator_loc: (284...286) = "::"
        │   ├── message_loc: (286...291) = "alias"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "alias"
        ├── @ CallNode (location: (293...299))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (293...294))
        │   │   └── name: :A
        │   ├── call_operator_loc: (294...296) = "::"
        │   ├── message_loc: (296...299) = "and"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "and"
        ├── @ CallNode (location: (301...309))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (301...302))
        │   │   └── name: :A
        │   ├── call_operator_loc: (302...304) = "::"
        │   ├── message_loc: (304...309) = "begin"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "begin"
        ├── @ ConstantPathNode (location: (311...319))
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (311...312))
        │   │   └── name: :A
        │   ├── child:
        │   │   @ ConstantReadNode (location: (314...319))
        │   │   └── name: :BEGIN
        │   └── delimiter_loc: (312...314) = "::"
        ├── @ CallNode (location: (321...329))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (321...322))
        │   │   └── name: :A
        │   ├── call_operator_loc: (322...324) = "::"
        │   ├── message_loc: (324...329) = "break"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "break"
        ├── @ CallNode (location: (331...339))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (331...332))
        │   │   └── name: :A
        │   ├── call_operator_loc: (332...334) = "::"
        │   ├── message_loc: (334...339) = "class"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "class"
        ├── @ CallNode (location: (341...347))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (341...342))
        │   │   └── name: :A
        │   ├── call_operator_loc: (342...344) = "::"
        │   ├── message_loc: (344...347) = "def"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "def"
        ├── @ CallNode (location: (349...359))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (349...350))
        │   │   └── name: :A
        │   ├── call_operator_loc: (350...352) = "::"
        │   ├── message_loc: (352...359) = "defined"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "defined"
        ├── @ CallNode (location: (361...366))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (361...362))
        │   │   └── name: :A
        │   ├── call_operator_loc: (362...364) = "::"
        │   ├── message_loc: (364...366) = "do"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "do"
        ├── @ CallNode (location: (368...375))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (368...369))
        │   │   └── name: :A
        │   ├── call_operator_loc: (369...371) = "::"
        │   ├── message_loc: (371...375) = "else"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "else"
        ├── @ CallNode (location: (377...385))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (377...378))
        │   │   └── name: :A
        │   ├── call_operator_loc: (378...380) = "::"
        │   ├── message_loc: (380...385) = "elsif"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "elsif"
        ├── @ CallNode (location: (387...393))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (387...388))
        │   │   └── name: :A
        │   ├── call_operator_loc: (388...390) = "::"
        │   ├── message_loc: (390...393) = "end"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "end"
        ├── @ ConstantPathNode (location: (395...401))
        │   ├── parent:
        │   │   @ ConstantReadNode (location: (395...396))
        │   │   └── name: :A
        │   ├── child:
        │   │   @ ConstantReadNode (location: (398...401))
        │   │   └── name: :END
        │   └── delimiter_loc: (396...398) = "::"
        ├── @ CallNode (location: (403...412))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (403...404))
        │   │   └── name: :A
        │   ├── call_operator_loc: (404...406) = "::"
        │   ├── message_loc: (406...412) = "ensure"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "ensure"
        ├── @ CallNode (location: (414...422))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (414...415))
        │   │   └── name: :A
        │   ├── call_operator_loc: (415...417) = "::"
        │   ├── message_loc: (417...422) = "false"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "false"
        ├── @ CallNode (location: (424...430))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (424...425))
        │   │   └── name: :A
        │   ├── call_operator_loc: (425...427) = "::"
        │   ├── message_loc: (427...430) = "for"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "for"
        ├── @ CallNode (location: (432...437))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (432...433))
        │   │   └── name: :A
        │   ├── call_operator_loc: (433...435) = "::"
        │   ├── message_loc: (435...437) = "if"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "if"
        ├── @ CallNode (location: (439...444))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (439...440))
        │   │   └── name: :A
        │   ├── call_operator_loc: (440...442) = "::"
        │   ├── message_loc: (442...444) = "in"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "in"
        ├── @ CallNode (location: (446...453))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (446...447))
        │   │   └── name: :A
        │   ├── call_operator_loc: (447...449) = "::"
        │   ├── message_loc: (449...453) = "next"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "next"
        ├── @ CallNode (location: (455...461))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (455...456))
        │   │   └── name: :A
        │   ├── call_operator_loc: (456...458) = "::"
        │   ├── message_loc: (458...461) = "nil"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "nil"
        ├── @ CallNode (location: (463...469))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (463...464))
        │   │   └── name: :A
        │   ├── call_operator_loc: (464...466) = "::"
        │   ├── message_loc: (466...469) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "not"
        ├── @ CallNode (location: (471...476))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (471...472))
        │   │   └── name: :A
        │   ├── call_operator_loc: (472...474) = "::"
        │   ├── message_loc: (474...476) = "or"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "or"
        ├── @ CallNode (location: (478...485))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (478...479))
        │   │   └── name: :A
        │   ├── call_operator_loc: (479...481) = "::"
        │   ├── message_loc: (481...485) = "redo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "redo"
        ├── @ CallNode (location: (487...496))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (487...488))
        │   │   └── name: :A
        │   ├── call_operator_loc: (488...490) = "::"
        │   ├── message_loc: (490...496) = "rescue"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "rescue"
        ├── @ CallNode (location: (498...506))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (498...499))
        │   │   └── name: :A
        │   ├── call_operator_loc: (499...501) = "::"
        │   ├── message_loc: (501...506) = "retry"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "retry"
        ├── @ CallNode (location: (508...517))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (508...509))
        │   │   └── name: :A
        │   ├── call_operator_loc: (509...511) = "::"
        │   ├── message_loc: (511...517) = "return"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "return"
        ├── @ CallNode (location: (519...526))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (519...520))
        │   │   └── name: :A
        │   ├── call_operator_loc: (520...522) = "::"
        │   ├── message_loc: (522...526) = "self"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "self"
        ├── @ CallNode (location: (528...536))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (528...529))
        │   │   └── name: :A
        │   ├── call_operator_loc: (529...531) = "::"
        │   ├── message_loc: (531...536) = "super"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "super"
        ├── @ CallNode (location: (538...545))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (538...539))
        │   │   └── name: :A
        │   ├── call_operator_loc: (539...541) = "::"
        │   ├── message_loc: (541...545) = "then"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "then"
        ├── @ CallNode (location: (547...554))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (547...548))
        │   │   └── name: :A
        │   ├── call_operator_loc: (548...550) = "::"
        │   ├── message_loc: (550...554) = "true"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "true"
        ├── @ CallNode (location: (556...564))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (556...557))
        │   │   └── name: :A
        │   ├── call_operator_loc: (557...559) = "::"
        │   ├── message_loc: (559...564) = "undef"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "undef"
        ├── @ CallNode (location: (566...575))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (566...567))
        │   │   └── name: :A
        │   ├── call_operator_loc: (567...569) = "::"
        │   ├── message_loc: (569...575) = "unless"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "unless"
        ├── @ CallNode (location: (577...585))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (577...578))
        │   │   └── name: :A
        │   ├── call_operator_loc: (578...580) = "::"
        │   ├── message_loc: (580...585) = "until"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "until"
        ├── @ CallNode (location: (587...594))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (587...588))
        │   │   └── name: :A
        │   ├── call_operator_loc: (588...590) = "::"
        │   ├── message_loc: (590...594) = "when"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "when"
        ├── @ CallNode (location: (596...604))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (596...597))
        │   │   └── name: :A
        │   ├── call_operator_loc: (597...599) = "::"
        │   ├── message_loc: (599...604) = "while"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "while"
        ├── @ CallNode (location: (606...614))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (606...607))
        │   │   └── name: :A
        │   ├── call_operator_loc: (607...609) = "::"
        │   ├── message_loc: (609...614) = "yield"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "yield"
        ├── @ CallNode (location: (616...631))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (616...617))
        │   │   └── name: :A
        │   ├── call_operator_loc: (617...619) = "::"
        │   ├── message_loc: (619...631) = "__ENCODING__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "__ENCODING__"
        ├── @ CallNode (location: (633...644))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (633...634))
        │   │   └── name: :A
        │   ├── call_operator_loc: (634...636) = "::"
        │   ├── message_loc: (636...644) = "__FILE__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "__FILE__"
        ├── @ CallNode (location: (646...657))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (646...647))
        │   │   └── name: :A
        │   ├── call_operator_loc: (647...649) = "::"
        │   ├── message_loc: (649...657) = "__LINE__"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "__LINE__"
        ├── @ CallNode (location: (659...663))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (659...660))
        │   │   └── name: :A
        │   ├── call_operator_loc: (660...662) = "::"
        │   ├── message_loc: (662...663) = "<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "<"
        ├── @ CallNode (location: (665...671))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (665...666))
        │   │   └── name: :A
        │   ├── call_operator_loc: (666...668) = "::"
        │   ├── message_loc: (668...671) = "<=>"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "<=>"
        ├── @ CallNode (location: (673...678))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (673...674))
        │   │   └── name: :A
        │   ├── call_operator_loc: (674...676) = "::"
        │   ├── message_loc: (676...678) = "<<"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "<<"
        ├── @ CallNode (location: (680...684))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (680...681))
        │   │   └── name: :A
        │   ├── call_operator_loc: (681...683) = "::"
        │   ├── message_loc: (683...684) = "-"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "-"
        ├── @ CallNode (location: (686...690))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (686...687))
        │   │   └── name: :A
        │   ├── call_operator_loc: (687...689) = "::"
        │   ├── message_loc: (689...690) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (692...697))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (692...693))
        │   │   └── name: :A
        │   ├── call_operator_loc: (693...695) = "::"
        │   ├── message_loc: (695...696) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (696...697))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (696...697))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (696...697) = "i"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "i"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (699...704))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (699...700))
        │   │   └── name: :A
        │   ├── call_operator_loc: (700...702) = "::"
        │   ├── message_loc: (702...703) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (703...704))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (703...704))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (703...704) = "w"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "w"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (706...711))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (706...707))
        │   │   └── name: :A
        │   ├── call_operator_loc: (707...709) = "::"
        │   ├── message_loc: (709...710) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (710...711))
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (710...711))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (710...711) = "x"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "x"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (713...718))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (713...714))
        │   │   └── name: :A
        │   ├── call_operator_loc: (714...716) = "::"
        │   ├── message_loc: (716...717) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (717...718))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ConstantReadNode (location: (717...718))
        │   │           └── name: :I
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (720...725))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (720...721))
        │   │   └── name: :A
        │   ├── call_operator_loc: (721...723) = "::"
        │   ├── message_loc: (723...724) = "%"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (724...725))
        │   │   └── arguments: (length: 1)
        │   │       └── @ ConstantReadNode (location: (724...725))
        │   │           └── name: :W
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "%"
        ├── @ CallNode (location: (727...731))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (727...728))
        │   │   └── name: :A
        │   ├── call_operator_loc: (728...730) = "::"
        │   ├── message_loc: (730...731) = "|"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "|"
        ├── @ CallNode (location: (733...737))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (733...734))
        │   │   └── name: :A
        │   ├── call_operator_loc: (734...736) = "::"
        │   ├── message_loc: (736...737) = "+"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "+"
        ├── @ CallNode (location: (739...743))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (739...740))
        │   │   └── name: :A
        │   ├── call_operator_loc: (740...742) = "::"
        │   ├── message_loc: (742...743) = "/"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "/"
        ├── @ CallNode (location: (745...749))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (745...746))
        │   │   └── name: :A
        │   ├── call_operator_loc: (746...748) = "::"
        │   ├── message_loc: (748...749) = "*"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "*"
        ├── @ CallNode (location: (751...756))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (751...752))
        │   │   └── name: :A
        │   ├── call_operator_loc: (752...754) = "::"
        │   ├── message_loc: (754...756) = "**"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "**"
        ├── @ CallNode (location: (758...762))
        │   ├── receiver:
        │   │   @ ConstantReadNode (location: (758...759))
        │   │   └── name: :A
        │   ├── call_operator_loc: (759...761) = "::"
        │   ├── message_loc: (761...762) = "~"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "~"
        ├── @ ConstantPathNode (location: (764...772))
        │   ├── parent:
        │   │   @ CallNode (location: (764...768))
        │   │   ├── receiver:
        │   │   │   @ ConstantReadNode (location: (764...765))
        │   │   │   └── name: :A
        │   │   ├── call_operator_loc: (765...767) = "::"
        │   │   ├── message_loc: (767...768) = "_"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── block: ∅
        │   │   ├── flags: ∅
        │   │   └── name: "_"
        │   ├── child:
        │   │   @ ConstantReadNode (location: (771...772))
        │   │   └── name: :C
        │   └── delimiter_loc: (768...770) = "::"
        └── @ RangeNode (location: (774...792))
            ├── left:
            │   @ CallNode (location: (774...778))
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (774...775))
            │   │   └── name: :A
            │   ├── call_operator_loc: (775...777) = "::"
            │   ├── message_loc: (777...778) = "_"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── block: ∅
            │   ├── flags: ∅
            │   └── name: "_"
            ├── right:
            │   @ CallNode (location: (782...792))
            │   ├── receiver:
            │   │   @ ConstantReadNode (location: (782...783))
            │   │   └── name: :A
            │   ├── call_operator_loc: (783...785) = "::"
            │   ├── message_loc: (785...792) = "__END__"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── block: ∅
            │   ├── flags: ∅
            │   └── name: "__END__"
            ├── operator_loc: (778...780) = ".."
            └── flags: ∅