diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/semantic/dstr.txt')
| -rw-r--r-- | test/prism/snapshots/unparser/corpus/semantic/dstr.txt | 598 |
1 files changed, 598 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/semantic/dstr.txt b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt new file mode 100644 index 0000000000..499bf59d1a --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt @@ -0,0 +1,598 @@ +@ ProgramNode (location: (1,0)-(127,11)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(127,11)) + └── body: (length: 33) + ├── @ StringNode (location: (1,0)-(1,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (1,0)-(1,5) = "<<DOC" + │ ├── content_loc: (2,0)-(2,0) = "" + │ ├── closing_loc: (2,0)-(3,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (4,0)-(4,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (4,0)-(4,7) = "<<'DOC'" + │ ├── content_loc: (5,0)-(5,0) = "" + │ ├── closing_loc: (5,0)-(6,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (7,0)-(7,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (7,0)-(7,6) = "<<~DOC" + │ ├── content_loc: (8,0)-(8,0) = "" + │ ├── closing_loc: (8,0)-(9,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (10,0)-(10,8)) + │ ├── flags: ∅ + │ ├── opening_loc: (10,0)-(10,8) = "<<~'DOC'" + │ ├── content_loc: (11,0)-(11,0) = "" + │ ├── closing_loc: (11,0)-(12,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (13,0)-(13,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (13,0)-(13,5) = "<<DOC" + │ ├── content_loc: (14,0)-(15,0) = " a\n" + │ ├── closing_loc: (15,0)-(16,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ StringNode (location: (17,0)-(17,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (17,0)-(17,7) = "<<'DOC'" + │ ├── content_loc: (18,0)-(19,0) = " a\n" + │ ├── closing_loc: (19,0)-(20,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ InterpolatedStringNode (location: (21,0)-(21,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (21,0)-(21,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (22,0)-(23,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (22,0)-(23,2) = " a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (23,2)-(23,5)) + │ │ │ ├── opening_loc: (23,2)-(23,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (23,4)-(23,5) = "}" + │ │ └── @ StringNode (location: (23,5)-(24,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (23,5)-(24,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (24,0)-(25,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (26,0)-(26,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (26,0)-(26,6) = "<<~DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (27,0)-(28,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (27,0)-(28,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (28,2)-(28,5)) + │ │ │ ├── opening_loc: (28,2)-(28,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (28,4)-(28,5) = "}" + │ │ └── @ StringNode (location: (28,5)-(29,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (28,5)-(29,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (29,0)-(30,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (31,0)-(31,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (31,0)-(31,6) = "<<~DOC" + │ ├── parts: (length: 4) + │ │ ├── @ StringNode (location: (32,0)-(33,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (32,0)-(33,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (33,2)-(33,5)) + │ │ │ ├── opening_loc: (33,2)-(33,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (33,4)-(33,5) = "}" + │ │ ├── @ StringNode (location: (33,5)-(34,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (33,5)-(34,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── @ StringNode (location: (34,0)-(35,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (34,0)-(35,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n" + │ └── closing_loc: (35,0)-(36,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (37,0)-(37,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (37,0)-(37,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (38,0)-(39,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (38,0)-(39,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── @ StringNode (location: (39,0)-(40,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (39,0)-(40,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " b\n" + │ └── closing_loc: (40,0)-(41,0) = "DOC\n" + ├── @ StringNode (location: (42,0)-(42,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (42,0)-(42,7) = "<<'DOC'" + │ ├── content_loc: (43,0)-(46,0) = "a\n\nb\n" + │ ├── closing_loc: (46,0)-(47,0) = "DOC\n" + │ └── unescaped: "a\n\nb\n" + ├── @ StringNode (location: (48,0)-(48,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (48,0)-(48,7) = "<<'DOC'" + │ ├── content_loc: (49,0)-(52,0) = " a\n\n b\n" + │ ├── closing_loc: (52,0)-(53,0) = "DOC\n" + │ └── unescaped: " a\n\n b\n" + ├── @ StringNode (location: (54,0)-(54,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (54,0)-(54,7) = "<<'DOC'" + │ ├── content_loc: (55,0)-(56,0) = " a\\nb\n" + │ ├── closing_loc: (56,0)-(57,0) = "DOC\n" + │ └── unescaped: " a\\nb\n" + ├── @ InterpolatedStringNode (location: (58,0)-(58,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (58,0)-(58,5) = "<<DOC" + │ ├── parts: (length: 4) + │ │ ├── @ EmbeddedStatementsNode (location: (59,0)-(59,3)) + │ │ │ ├── opening_loc: (59,0)-(59,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (59,2)-(59,3) = "}" + │ │ ├── @ StringNode (location: (59,3)-(60,1)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (59,3)-(60,1) = "a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (60,1)-(60,4)) + │ │ │ ├── opening_loc: (60,1)-(60,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (60,3)-(60,4) = "}" + │ │ └── @ StringNode (location: (60,4)-(61,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (60,4)-(61,0) = "a\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a\n" + │ └── closing_loc: (61,0)-(62,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (63,0)-(63,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (63,0)-(63,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (64,0)-(64,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (64,0)-(64,2) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedStatementsNode (location: (64,2)-(64,5)) + │ │ │ ├── opening_loc: (64,2)-(64,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (64,4)-(64,5) = "}" + │ │ └── @ StringNode (location: (64,5)-(66,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (64,5)-(66,0) = "\n \\\#{}\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n \#{}\n" + │ └── closing_loc: (66,0)-(67,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (68,0)-(68,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (68,0)-(68,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (69,0)-(69,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (69,0)-(69,2) = " a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a" + │ │ ├── @ EmbeddedStatementsNode (location: (69,2)-(69,5)) + │ │ │ ├── opening_loc: (69,2)-(69,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (69,4)-(69,5) = "}" + │ │ └── @ StringNode (location: (69,5)-(71,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (69,5)-(71,0) = "b\n c\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n c\n" + │ └── closing_loc: (71,0)-(72,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (73,0)-(73,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (73,0)-(73,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (74,2)-(74,5)) + │ │ │ ├── opening_loc: (74,2)-(74,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (74,4)-(74,5) = "}" + │ │ └── @ StringNode (location: (74,5)-(75,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (74,5)-(75,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (75,0)-(76,0) = "DOC\n" + ├── @ IfNode (location: (77,0)-(81,3)) + │ ├── if_keyword_loc: (77,0)-(77,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (77,3)-(77,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (78,2)-(78,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (78,2)-(78,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (78,2)-(78,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (79,4)-(79,7)) + │ │ │ │ ├── opening_loc: (79,4)-(79,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (79,6)-(79,7) = "}" + │ │ │ └── @ StringNode (location: (79,7)-(80,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (79,7)-(80,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (80,0)-(81,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (81,0)-(81,3) = "end" + ├── @ IfNode (location: (83,0)-(87,3)) + │ ├── if_keyword_loc: (83,0)-(83,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (83,3)-(83,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (84,2)-(84,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (84,2)-(84,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (84,2)-(84,8) = "<<~DOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (85,0)-(85,5)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (85,0)-(85,5) = " b" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "b" + │ │ │ ├── @ EmbeddedStatementsNode (location: (85,5)-(85,8)) + │ │ │ │ ├── opening_loc: (85,5)-(85,7) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (85,7)-(85,8) = "}" + │ │ │ └── @ StringNode (location: (85,8)-(86,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (85,8)-(86,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (86,0)-(87,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (87,0)-(87,3) = "end" + ├── @ IfNode (location: (89,0)-(93,3)) + │ ├── if_keyword_loc: (89,0)-(89,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (89,3)-(89,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (90,2)-(90,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (90,2)-(90,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (90,2)-(90,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (91,4)-(91,7)) + │ │ │ │ ├── opening_loc: (91,4)-(91,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (91,6)-(91,7) = "}" + │ │ │ └── @ StringNode (location: (91,7)-(92,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (91,7)-(92,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── closing_loc: (92,0)-(93,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (93,0)-(93,3) = "end" + ├── @ IfNode (location: (95,0)-(101,3)) + │ ├── if_keyword_loc: (95,0)-(95,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (95,3)-(95,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (96,2)-(96,10)) + │ │ └── body: (length: 1) + │ │ └── @ StringNode (location: (96,2)-(96,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (96,2)-(96,10) = "<<-'DOC'" + │ │ ├── content_loc: (97,0)-(100,0) = " a\n\n b\n" + │ │ ├── closing_loc: (100,0)-(101,0) = " DOC\n" + │ │ └── unescaped: " a\n\n b\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (101,0)-(101,3) = "end" + ├── @ InterpolatedStringNode (location: (103,0)-(103,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (103,0)-(103,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (103,1)-(103,4)) + │ │ │ ├── opening_loc: (103,1)-(103,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (103,3)-(103,4) = "}" + │ │ └── @ StringNode (location: (103,4)-(103,5)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (103,4)-(103,5) = "a" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a" + │ └── closing_loc: (103,5)-(103,6) = "\"" + ├── @ InterpolatedStringNode (location: (105,0)-(105,12)) + │ ├── flags: ∅ + │ ├── opening_loc: (105,0)-(105,2) = "%(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (105,2)-(105,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (105,2)-(105,5) = "\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (105,5)-(105,8)) + │ │ │ ├── opening_loc: (105,5)-(105,7) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (105,7)-(105,8) = "}" + │ │ └── @ StringNode (location: (105,8)-(105,11)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (105,8)-(105,11) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (105,11)-(105,12) = ")" + ├── @ InterpolatedStringNode (location: (107,0)-(107,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (107,0)-(107,3) = "%Q(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (107,3)-(107,7)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (107,3)-(107,7) = "-\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "-\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (107,7)-(107,10)) + │ │ │ ├── opening_loc: (107,7)-(107,9) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (107,9)-(107,10) = "}" + │ │ └── @ StringNode (location: (107,10)-(107,13)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (107,10)-(107,13) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (107,13)-(107,14) = ")" + ├── @ InterpolatedStringNode (location: (109,0)-(111,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (109,0)-(109,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (109,1)-(110,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (109,1)-(110,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (110,0)-(110,3)) + │ │ │ ├── opening_loc: (110,0)-(110,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (110,2)-(110,3) = "}" + │ │ └── @ StringNode (location: (110,3)-(111,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (110,3)-(111,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (111,1)-(111,2) = "\"" + ├── @ InterpolatedStringNode (location: (113,0)-(114,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (113,0)-(113,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (113,1)-(113,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (113,1)-(113,4) = "a\\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (113,4)-(113,7)) + │ │ │ ├── opening_loc: (113,4)-(113,6) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (113,6)-(113,7) = "}" + │ │ └── @ StringNode (location: (113,7)-(114,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (113,7)-(114,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (114,1)-(114,2) = "\"" + ├── @ InterpolatedStringNode (location: (116,0)-(117,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (116,0)-(116,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (116,1)-(117,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (116,1)-(117,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (117,0)-(117,3)) + │ │ │ ├── opening_loc: (117,0)-(117,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (117,2)-(117,3) = "}" + │ │ └── @ StringNode (location: (117,3)-(117,6)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (117,3)-(117,6) = "\\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (117,6)-(117,7) = "\"" + ├── @ InterpolatedStringNode (location: (119,0)-(120,5)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (119,0)-(119,3)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (119,0)-(119,1) = "'" + │ │ │ ├── content_loc: (119,1)-(119,2) = "a" + │ │ │ ├── closing_loc: (119,2)-(119,3) = "'" + │ │ │ └── unescaped: "a" + │ │ └── @ InterpolatedStringNode (location: (120,0)-(120,5)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (120,0)-(120,1) = "\"" + │ │ ├── parts: (length: 1) + │ │ │ └── @ EmbeddedStatementsNode (location: (120,1)-(120,4)) + │ │ │ ├── opening_loc: (120,1)-(120,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (120,3)-(120,4) = "}" + │ │ └── closing_loc: (120,4)-(120,5) = "\"" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (122,0)-(122,8)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (122,0)-(122,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,0)-(122,1) = "\"" + │ │ │ ├── content_loc: (122,1)-(122,1) = "" + │ │ │ ├── closing_loc: (122,1)-(122,2) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── @ StringNode (location: (122,3)-(122,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,3)-(122,4) = "\"" + │ │ │ ├── content_loc: (122,4)-(122,4) = "" + │ │ │ ├── closing_loc: (122,4)-(122,5) = "\"" + │ │ │ └── unescaped: "" + │ │ └── @ StringNode (location: (122,6)-(122,8)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (122,6)-(122,7) = "\"" + │ │ ├── content_loc: (122,7)-(122,7) = "" + │ │ ├── closing_loc: (122,7)-(122,8) = "\"" + │ │ └── unescaped: "" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (124,0)-(124,12)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (124,0)-(124,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (124,0)-(124,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (124,1)-(124,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (124,1)-(124,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedStatementsNode (location: (124,2)-(124,7)) + │ │ │ │ ├── opening_loc: (124,2)-(124,4) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ InstanceVariableReadNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── name: :@a + │ │ │ │ └── closing_loc: (124,6)-(124,7) = "}" + │ │ │ └── closing_loc: (124,7)-(124,8) = "\"" + │ │ └── @ StringNode (location: (124,9)-(124,12)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (124,9)-(124,10) = "\"" + │ │ ├── content_loc: (124,10)-(124,11) = "b" + │ │ ├── closing_loc: (124,11)-(124,12) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (125,0)-(125,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (125,0)-(125,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (125,0)-(125,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (125,1)-(125,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (125,1)-(125,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (125,2)-(125,5)) + │ │ │ │ ├── operator_loc: (125,2)-(125,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ InstanceVariableReadNode (location: (125,3)-(125,5)) + │ │ │ │ └── name: :@a + │ │ │ └── closing_loc: (125,5)-(125,6) = "\"" + │ │ └── @ StringNode (location: (125,7)-(125,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (125,7)-(125,8) = "\"" + │ │ ├── content_loc: (125,8)-(125,9) = "b" + │ │ ├── closing_loc: (125,9)-(125,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (126,0)-(126,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (126,0)-(126,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (126,0)-(126,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (126,1)-(126,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (126,1)-(126,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (126,2)-(126,5)) + │ │ │ │ ├── operator_loc: (126,2)-(126,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ GlobalVariableReadNode (location: (126,3)-(126,5)) + │ │ │ │ └── name: :$a + │ │ │ └── closing_loc: (126,5)-(126,6) = "\"" + │ │ └── @ StringNode (location: (126,7)-(126,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (126,7)-(126,8) = "\"" + │ │ ├── content_loc: (126,8)-(126,9) = "b" + │ │ ├── closing_loc: (126,9)-(126,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + └── @ InterpolatedStringNode (location: (127,0)-(127,11)) + ├── flags: ∅ + ├── opening_loc: ∅ + ├── parts: (length: 2) + │ ├── @ InterpolatedStringNode (location: (127,0)-(127,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (127,0)-(127,1) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ StringNode (location: (127,1)-(127,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (127,1)-(127,2) = "a" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a" + │ │ │ └── @ EmbeddedVariableNode (location: (127,2)-(127,6)) + │ │ │ ├── operator_loc: (127,2)-(127,3) = "#" + │ │ │ └── variable: + │ │ │ @ ClassVariableReadNode (location: (127,3)-(127,6)) + │ │ │ └── name: :@@a + │ │ └── closing_loc: (127,6)-(127,7) = "\"" + │ └── @ StringNode (location: (127,8)-(127,11)) + │ ├── flags: frozen + │ ├── opening_loc: (127,8)-(127,9) = "\"" + │ ├── content_loc: (127,9)-(127,10) = "b" + │ ├── closing_loc: (127,10)-(127,11) = "\"" + │ └── unescaped: "b" + └── closing_loc: ∅ |