path: root/test/yarp/snapshots/unparser/corpus/semantic/dstr.txt

@ ProgramNode (location: (0...608))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...608))
    └── body: (length: 33)
        ├── @ InterpolatedStringNode (location: (0...5))
        │   ├── opening_loc: (0...5) = "<<DOC"
        │   ├── parts: (length: 0)
        │   └── closing_loc: (6...10) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (11...18))
        │   ├── opening_loc: (11...18) = "<<'DOC'"
        │   ├── parts: (length: 0)
        │   └── closing_loc: (19...23) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (24...30))
        │   ├── opening_loc: (24...30) = "<<~DOC"
        │   ├── parts: (length: 0)
        │   └── closing_loc: (31...35) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (36...44))
        │   ├── opening_loc: (36...44) = "<<~'DOC'"
        │   ├── parts: (length: 0)
        │   └── closing_loc: (45...49) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (50...55))
        │   ├── opening_loc: (50...55) = "<<DOC"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (56...60))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (56...60) = "  a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "  a\n"
        │   └── closing_loc: (60...64) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (65...72))
        │   ├── opening_loc: (65...72) = "<<'DOC'"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (73...77))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (73...77) = "  a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "  a\n"
        │   └── closing_loc: (77...81) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (82...87))
        │   ├── opening_loc: (82...87) = "<<DOC"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (88...94))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (88...94) = "  a\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  a\n  "
        │   │   ├── @ EmbeddedStatementsNode (location: (94...97))
        │   │   │   ├── opening_loc: (94...96) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (96...97) = "}"
        │   │   └── @ StringNode (location: (97...98))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (97...98) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (98...102) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (103...109))
        │   ├── opening_loc: (103...109) = "<<~DOC"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (110...116))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (110...116) = "  a\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (116...119))
        │   │   │   ├── opening_loc: (116...118) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (118...119) = "}"
        │   │   └── @ StringNode (location: (119...120))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (119...120) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (120...124) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (125...131))
        │   ├── opening_loc: (125...131) = "<<~DOC"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (132...138))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (132...138) = "  a\n  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (138...141))
        │   │   │   ├── opening_loc: (138...140) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (140...141) = "}"
        │   │   └── @ StringNode (location: (141...146))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (141...146) = "\n  b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\nb\n"
        │   └── closing_loc: (146...150) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (151...157))
        │   ├── opening_loc: (151...157) = "<<~DOC"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (158...168))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (158...168) = "  a\n    b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n  b\n"
        │   └── closing_loc: (168...172) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (173...180))
        │   ├── opening_loc: (173...180) = "<<'DOC'"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (181...186))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (181...186) = "a\n\nb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n\nb\n"
        │   └── closing_loc: (186...190) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (191...198))
        │   ├── opening_loc: (191...198) = "<<'DOC'"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (199...206))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (199...206) = " a\n\n b\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " a\n\n b\n"
        │   └── closing_loc: (206...210) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (211...218))
        │   ├── opening_loc: (211...218) = "<<'DOC'"
        │   ├── parts: (length: 1)
        │   │   └── @ StringNode (location: (219...225))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (219...225) = " a\\nb\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " a\\nb\n"
        │   └── closing_loc: (225...229) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (230...235))
        │   ├── opening_loc: (230...235) = "<<DOC"
        │   ├── parts: (length: 4)
        │   │   ├── @ EmbeddedStatementsNode (location: (236...239))
        │   │   │   ├── opening_loc: (236...238) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (238...239) = "}"
        │   │   ├── @ StringNode (location: (239...242))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (239...242) = "a\n "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n "
        │   │   ├── @ EmbeddedStatementsNode (location: (242...245))
        │   │   │   ├── opening_loc: (242...244) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (244...245) = "}"
        │   │   └── @ StringNode (location: (245...247))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (245...247) = "a\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a\n"
        │   └── closing_loc: (247...251) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (252...257))
        │   ├── opening_loc: (252...257) = "<<DOC"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (258...260))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (258...260) = "  "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "  "
        │   │   ├── @ EmbeddedStatementsNode (location: (260...263))
        │   │   │   ├── opening_loc: (260...262) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (262...263) = "}"
        │   │   └── @ StringNode (location: (263...271))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (263...271) = "\n  \\\#{}\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n  \#{}\n"
        │   └── closing_loc: (271...275) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (276...281))
        │   ├── opening_loc: (276...281) = "<<DOC"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (282...284))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (282...284) = " a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: " a"
        │   │   ├── @ EmbeddedStatementsNode (location: (284...287))
        │   │   │   ├── opening_loc: (284...286) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (286...287) = "}"
        │   │   └── @ StringNode (location: (287...292))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (287...292) = "b\n c\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "b\n c\n"
        │   └── closing_loc: (292...296) = "DOC\n"
        ├── @ InterpolatedStringNode (location: (297...303))
        │   ├── opening_loc: (297...303) = "<<~DOC"
        │   ├── parts: (length: 2)
        │   │   ├── @ EmbeddedStatementsNode (location: (306...309))
        │   │   │   ├── opening_loc: (306...308) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (308...309) = "}"
        │   │   └── @ StringNode (location: (309...310))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (309...310) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (310...314) = "DOC\n"
        ├── @ IfNode (location: (315...349))
        │   ├── if_keyword_loc: (315...317) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (318...322))
        │   ├── statements:
        │   │   @ StatementsNode (location: (325...331))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (325...331))
        │   │           ├── opening_loc: (325...331) = "<<~DOC"
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ EmbeddedStatementsNode (location: (336...339))
        │   │           │   │   ├── opening_loc: (336...338) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (338...339) = "}"
        │   │           │   └── @ StringNode (location: (339...340))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (339...340) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (340...346) = "  DOC\n"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (346...349) = "end"
        ├── @ IfNode (location: (351...386))
        │   ├── if_keyword_loc: (351...353) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (354...358))
        │   ├── statements:
        │   │   @ StatementsNode (location: (361...367))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (361...367))
        │   │           ├── opening_loc: (361...367) = "<<~DOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (368...373))
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (368...373) = "    b"
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "b"
        │   │           │   ├── @ EmbeddedStatementsNode (location: (373...376))
        │   │           │   │   ├── opening_loc: (373...375) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (375...376) = "}"
        │   │           │   └── @ StringNode (location: (376...377))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (376...377) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (377...383) = "  DOC\n"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (383...386) = "end"
        ├── @ IfNode (location: (388...423))
        │   ├── if_keyword_loc: (388...390) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (391...395))
        │   ├── statements:
        │   │   @ StatementsNode (location: (398...404))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (398...404))
        │   │           ├── opening_loc: (398...404) = "<<~DOC"
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ EmbeddedStatementsNode (location: (409...412))
        │   │           │   │   ├── opening_loc: (409...411) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (411...412) = "}"
        │   │           │   └── @ StringNode (location: (412...414))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (412...414) = "a\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "a\n"
        │   │           └── closing_loc: (414...420) = "  DOC\n"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (420...423) = "end"
        ├── @ IfNode (location: (425...464))
        │   ├── if_keyword_loc: (425...427) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (428...432))
        │   ├── statements:
        │   │   @ StatementsNode (location: (435...443))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (435...443))
        │   │           ├── opening_loc: (435...443) = "<<-'DOC'"
        │   │           ├── parts: (length: 1)
        │   │           │   └── @ StringNode (location: (444...455))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (444...455) = "   a\n\n   b\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "   a\n\n   b\n"
        │   │           └── closing_loc: (455...461) = "  DOC\n"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (461...464) = "end"
        ├── @ InterpolatedStringNode (location: (466...472))
        │   ├── opening_loc: (466...467) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ EmbeddedStatementsNode (location: (467...470))
        │   │   │   ├── opening_loc: (467...469) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (469...470) = "}"
        │   │   └── @ StringNode (location: (470...471))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (470...471) = "a"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "a"
        │   └── closing_loc: (471...472) = "\""
        ├── @ InterpolatedStringNode (location: (474...486))
        │   ├── opening_loc: (474...476) = "%("
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (476...479))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (476...479) = "\\n\""
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n\""
        │   │   ├── @ EmbeddedStatementsNode (location: (479...482))
        │   │   │   ├── opening_loc: (479...481) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (481...482) = "}"
        │   │   └── @ StringNode (location: (482...485))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (482...485) = "\"\\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\"\n"
        │   └── closing_loc: (485...486) = ")"
        ├── @ InterpolatedStringNode (location: (488...502))
        │   ├── opening_loc: (488...491) = "%Q("
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (491...495))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (491...495) = "-\\n\""
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "-\n\""
        │   │   ├── @ EmbeddedStatementsNode (location: (495...498))
        │   │   │   ├── opening_loc: (495...497) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (497...498) = "}"
        │   │   └── @ StringNode (location: (498...501))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (498...501) = "\"\\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\"\n"
        │   └── closing_loc: (501...502) = ")"
        ├── @ InterpolatedStringNode (location: (504...513))
        │   ├── opening_loc: (504...505) = "\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (505...507))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (505...507) = "a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (507...510))
        │   │   │   ├── opening_loc: (507...509) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (509...510) = "}"
        │   │   └── @ StringNode (location: (510...512))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (510...512) = "\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\nb"
        │   └── closing_loc: (512...513) = "\""
        ├── @ InterpolatedStringNode (location: (515...525))
        │   ├── opening_loc: (515...516) = "\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (516...519))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (516...519) = "a\\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (519...522))
        │   │   │   ├── opening_loc: (519...521) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (521...522) = "}"
        │   │   └── @ StringNode (location: (522...524))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (522...524) = "\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\nb"
        │   └── closing_loc: (524...525) = "\""
        ├── @ InterpolatedStringNode (location: (527...537))
        │   ├── opening_loc: (527...528) = "\""
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (528...530))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (528...530) = "a\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (530...533))
        │   │   │   ├── opening_loc: (530...532) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (532...533) = "}"
        │   │   └── @ StringNode (location: (533...536))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (533...536) = "\\nb"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\nb"
        │   └── closing_loc: (536...537) = "\""
        ├── @ StringConcatNode (location: (539...550))
        │   ├── left:
        │   │   @ StringNode (location: (539...542))
        │   │   ├── opening_loc: (539...540) = "'"
        │   │   ├── content_loc: (540...541) = "a"
        │   │   ├── closing_loc: (541...542) = "'"
        │   │   └── unescaped: "a"
        │   └── right:
        │       @ InterpolatedStringNode (location: (545...550))
        │       ├── opening_loc: (545...546) = "\""
        │       ├── parts: (length: 1)
        │       │   └── @ EmbeddedStatementsNode (location: (546...549))
        │       │       ├── opening_loc: (546...548) = "\#{"
        │       │       ├── statements: ∅
        │       │       └── closing_loc: (548...549) = "}"
        │       └── closing_loc: (549...550) = "\""
        ├── @ StringConcatNode (location: (552...560))
        │   ├── left:
        │   │   @ StringConcatNode (location: (552...557))
        │   │   ├── left:
        │   │   │   @ StringNode (location: (552...554))
        │   │   │   ├── opening_loc: (552...553) = "\""
        │   │   │   ├── content_loc: (553...553) = ""
        │   │   │   ├── closing_loc: (553...554) = "\""
        │   │   │   └── unescaped: ""
        │   │   └── right:
        │   │       @ StringNode (location: (555...557))
        │   │       ├── opening_loc: (555...556) = "\""
        │   │       ├── content_loc: (556...556) = ""
        │   │       ├── closing_loc: (556...557) = "\""
        │   │       └── unescaped: ""
        │   └── right:
        │       @ StringNode (location: (558...560))
        │       ├── opening_loc: (558...559) = "\""
        │       ├── content_loc: (559...559) = ""
        │       ├── closing_loc: (559...560) = "\""
        │       └── unescaped: ""
        ├── @ StringConcatNode (location: (562...574))
        │   ├── left:
        │   │   @ InterpolatedStringNode (location: (562...570))
        │   │   ├── opening_loc: (562...563) = "\""
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ StringNode (location: (563...564))
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (563...564) = "a"
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "a"
        │   │   │   └── @ EmbeddedStatementsNode (location: (564...569))
        │   │   │       ├── opening_loc: (564...566) = "\#{"
        │   │   │       ├── statements:
        │   │   │       │   @ StatementsNode (location: (566...568))
        │   │   │       │   └── body: (length: 1)
        │   │   │       │       └── @ InstanceVariableReadNode (location: (566...568))
        │   │   │       │           └── name: :@a
        │   │   │       └── closing_loc: (568...569) = "}"
        │   │   └── closing_loc: (569...570) = "\""
        │   └── right:
        │       @ StringNode (location: (571...574))
        │       ├── opening_loc: (571...572) = "\""
        │       ├── content_loc: (572...573) = "b"
        │       ├── closing_loc: (573...574) = "\""
        │       └── unescaped: "b"
        ├── @ StringConcatNode (location: (575...585))
        │   ├── left:
        │   │   @ InterpolatedStringNode (location: (575...581))
        │   │   ├── opening_loc: (575...576) = "\""
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ StringNode (location: (576...577))
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (576...577) = "a"
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "a"
        │   │   │   └── @ EmbeddedVariableNode (location: (577...580))
        │   │   │       ├── operator_loc: (577...578) = "#"
        │   │   │       └── variable:
        │   │   │           @ InstanceVariableReadNode (location: (578...580))
        │   │   │           └── name: :@a
        │   │   └── closing_loc: (580...581) = "\""
        │   └── right:
        │       @ StringNode (location: (582...585))
        │       ├── opening_loc: (582...583) = "\""
        │       ├── content_loc: (583...584) = "b"
        │       ├── closing_loc: (584...585) = "\""
        │       └── unescaped: "b"
        ├── @ StringConcatNode (location: (586...596))
        │   ├── left:
        │   │   @ InterpolatedStringNode (location: (586...592))
        │   │   ├── opening_loc: (586...587) = "\""
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ StringNode (location: (587...588))
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (587...588) = "a"
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "a"
        │   │   │   └── @ EmbeddedVariableNode (location: (588...591))
        │   │   │       ├── operator_loc: (588...589) = "#"
        │   │   │       └── variable:
        │   │   │           @ GlobalVariableReadNode (location: (589...591))
        │   │   │           └── name: :$a
        │   │   └── closing_loc: (591...592) = "\""
        │   └── right:
        │       @ StringNode (location: (593...596))
        │       ├── opening_loc: (593...594) = "\""
        │       ├── content_loc: (594...595) = "b"
        │       ├── closing_loc: (595...596) = "\""
        │       └── unescaped: "b"
        └── @ StringConcatNode (location: (597...608))
            ├── left:
            │   @ InterpolatedStringNode (location: (597...604))
            │   ├── opening_loc: (597...598) = "\""
            │   ├── parts: (length: 2)
            │   │   ├── @ StringNode (location: (598...599))
            │   │   │   ├── opening_loc: ∅
            │   │   │   ├── content_loc: (598...599) = "a"
            │   │   │   ├── closing_loc: ∅
            │   │   │   └── unescaped: "a"
            │   │   └── @ EmbeddedVariableNode (location: (599...603))
            │   │       ├── operator_loc: (599...600) = "#"
            │   │       └── variable:
            │   │           @ ClassVariableReadNode (location: (600...603))
            │   │           └── name: :@@a
            │   └── closing_loc: (603...604) = "\""
            └── right:
                @ StringNode (location: (605...608))
                ├── opening_loc: (605...606) = "\""
                ├── content_loc: (606...607) = "b"
                ├── closing_loc: (607...608) = "\""
                └── unescaped: "b"