diff options
Diffstat (limited to 'test/prism/snapshots/regex.txt')
| -rw-r--r-- | test/prism/snapshots/regex.txt | 510 |
1 files changed, 510 insertions, 0 deletions
diff --git a/test/prism/snapshots/regex.txt b/test/prism/snapshots/regex.txt new file mode 100644 index 0000000000..d4d153e8d5 --- /dev/null +++ b/test/prism/snapshots/regex.txt @@ -0,0 +1,510 @@ +@ ProgramNode (location: (1,0)-(46,32)) +├── locals: [:foo, :ab, :abc, :a] +└── statements: + @ StatementsNode (location: (1,0)-(46,32)) + └── body: (length: 25) + ├── @ CallNode (location: (1,0)-(1,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (1,4)-(1,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ RegularExpressionNode (location: (1,4)-(1,9)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (1,4)-(1,5) = "/" + │ │ ├── content_loc: (1,5)-(1,8) = "bar" + │ │ ├── closing_loc: (1,8)-(1,9) = "/" + │ │ └── unescaped: "bar" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ RegularExpressionNode (location: (3,0)-(3,8)) + │ ├── flags: ignore_case, forced_us_ascii_encoding + │ ├── opening_loc: (3,0)-(3,3) = "%r{" + │ ├── content_loc: (3,3)-(3,6) = "abc" + │ ├── closing_loc: (3,6)-(3,8) = "}i" + │ └── unescaped: "abc" + ├── @ RegularExpressionNode (location: (5,0)-(5,5)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (5,0)-(5,1) = "/" + │ ├── content_loc: (5,1)-(5,4) = "a\\b" + │ ├── closing_loc: (5,4)-(5,5) = "/" + │ └── unescaped: "a\\b" + ├── @ InterpolatedRegularExpressionNode (location: (7,0)-(7,11)) + │ ├── flags: ∅ + │ ├── opening_loc: (7,0)-(7,1) = "/" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (7,1)-(7,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (7,1)-(7,5) = "aaa " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "aaa " + │ │ └── @ EmbeddedVariableNode (location: (7,5)-(7,10)) + │ │ ├── operator_loc: (7,5)-(7,6) = "#" + │ │ └── variable: + │ │ @ GlobalVariableReadNode (location: (7,6)-(7,10)) + │ │ └── name: :$bbb + │ └── closing_loc: (7,10)-(7,11) = "/" + ├── @ InterpolatedRegularExpressionNode (location: (9,0)-(9,16)) + │ ├── flags: ∅ + │ ├── opening_loc: (9,0)-(9,1) = "/" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (9,1)-(9,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (9,1)-(9,5) = "aaa " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "aaa " + │ │ ├── @ EmbeddedStatementsNode (location: (9,5)-(9,11)) + │ │ │ ├── opening_loc: (9,5)-(9,7) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (9,7)-(9,10)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (9,7)-(9,10)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bbb + │ │ │ │ ├── message_loc: (9,7)-(9,10) = "bbb" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (9,10)-(9,11) = "}" + │ │ └── @ StringNode (location: (9,11)-(9,15)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (9,11)-(9,15) = " ccc" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " ccc" + │ └── closing_loc: (9,15)-(9,16) = "/" + ├── @ ArrayNode (location: (11,0)-(11,27)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ MatchWriteNode (location: (11,1)-(11,21)) + │ │ │ ├── call: + │ │ │ │ @ CallNode (location: (11,1)-(11,21)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── receiver: + │ │ │ │ │ @ RegularExpressionNode (location: (11,1)-(11,14)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: (11,1)-(11,2) = "/" + │ │ │ │ │ ├── content_loc: (11,2)-(11,13) = "(?<foo>bar)" + │ │ │ │ │ ├── closing_loc: (11,13)-(11,14) = "/" + │ │ │ │ │ └── unescaped: "(?<foo>bar)" + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :=~ + │ │ │ │ ├── message_loc: (11,15)-(11,17) = "=~" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (11,18)-(11,21)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (11,18)-(11,21)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :baz + │ │ │ │ │ ├── message_loc: (11,18)-(11,21) = "baz" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── targets: (length: 1) + │ │ │ └── @ LocalVariableTargetNode (location: (11,5)-(11,8)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ └── @ LocalVariableReadNode (location: (11,23)-(11,26)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── opening_loc: (11,0)-(11,1) = "[" + │ └── closing_loc: (11,26)-(11,27) = "]" + ├── @ RegularExpressionNode (location: (13,0)-(13,6)) + │ ├── flags: ignore_case, forced_us_ascii_encoding + │ ├── opening_loc: (13,0)-(13,1) = "/" + │ ├── content_loc: (13,1)-(13,4) = "abc" + │ ├── closing_loc: (13,4)-(13,6) = "/i" + │ └── unescaped: "abc" + ├── @ RegularExpressionNode (location: (15,0)-(15,26)) + │ ├── flags: ignore_case, forced_us_ascii_encoding + │ ├── opening_loc: (15,0)-(15,3) = "%r/" + │ ├── content_loc: (15,3)-(15,24) = "[a-z$._?][\\w$.?\#@~]*:" + │ ├── closing_loc: (15,24)-(15,26) = "/i" + │ └── unescaped: "[a-z$._?][\\w$.?\#@~]*:" + ├── @ RegularExpressionNode (location: (17,0)-(17,37)) + │ ├── flags: ignore_case, forced_us_ascii_encoding + │ ├── opening_loc: (17,0)-(17,3) = "%r/" + │ ├── content_loc: (17,3)-(17,35) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)" + │ ├── closing_loc: (17,35)-(17,37) = "/i" + │ └── unescaped: "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)" + ├── @ RegularExpressionNode (location: (19,0)-(19,25)) + │ ├── flags: ignore_case, forced_us_ascii_encoding + │ ├── opening_loc: (19,0)-(19,3) = "%r/" + │ ├── content_loc: (19,3)-(19,23) = "[a-z$._?][\\w$.?\#@~]*" + │ ├── closing_loc: (19,23)-(19,25) = "/i" + │ └── unescaped: "[a-z$._?][\\w$.?\#@~]*" + ├── @ RegularExpressionNode (location: (21,0)-(24,1)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (21,0)-(21,3) = "%r(" + │ ├── content_loc: (21,3)-(24,0) = "\n(?:[\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\#$%_']+)\n" + │ ├── closing_loc: (24,0)-(24,1) = ")" + │ └── unescaped: "\n(?:[\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\#$%_']+)\n" + ├── @ CallNode (location: (26,0)-(26,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (26,0)-(26,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (26,0)-(26,1) = "/" + │ │ ├── content_loc: (26,1)-(26,7) = "(?#\\))" + │ │ ├── closing_loc: (26,7)-(26,8) = "/" + │ │ └── unescaped: "(?#\\))" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (26,9)-(26,11) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (26,12)-(26,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (26,12)-(26,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (26,12)-(26,13) = "\"" + │ │ ├── content_loc: (26,13)-(26,15) = "hi" + │ │ ├── closing_loc: (26,15)-(26,16) = "\"" + │ │ └── unescaped: "hi" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ RegularExpressionNode (location: (28,0)-(28,9)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (28,0)-(28,3) = "%r#" + │ ├── content_loc: (28,3)-(28,8) = "pound" + │ ├── closing_loc: (28,8)-(28,9) = "#" + │ └── unescaped: "pound" + ├── @ InterpolatedRegularExpressionNode (location: (30,0)-(30,13)) + │ ├── flags: once + │ ├── opening_loc: (30,0)-(30,1) = "/" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (30,1)-(30,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (30,1)-(30,5) = "aaa " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "aaa " + │ │ └── @ EmbeddedStatementsNode (location: (30,5)-(30,11)) + │ │ ├── opening_loc: (30,5)-(30,7) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (30,7)-(30,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (30,7)-(30,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bbb + │ │ │ ├── message_loc: (30,7)-(30,10) = "bbb" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── closing_loc: (30,10)-(30,11) = "}" + │ └── closing_loc: (30,11)-(30,13) = "/o" + ├── @ MatchWriteNode (location: (32,0)-(33,10)) + │ ├── call: + │ │ @ CallNode (location: (32,0)-(33,10)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ RegularExpressionNode (location: (32,0)-(33,4)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (32,0)-(32,1) = "/" + │ │ │ ├── content_loc: (32,1)-(33,3) = "(?<a\\\nb>)" + │ │ │ ├── closing_loc: (33,3)-(33,4) = "/" + │ │ │ └── unescaped: "(?<ab>)" + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :=~ + │ │ ├── message_loc: (33,5)-(33,7) = "=~" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (33,8)-(33,10)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (33,8)-(33,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (33,8)-(33,9) = "\"" + │ │ │ ├── content_loc: (33,9)-(33,9) = "" + │ │ │ ├── closing_loc: (33,9)-(33,10) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── targets: (length: 1) + │ └── @ LocalVariableTargetNode (location: (32,0)-(33,4)) + │ ├── name: :ab + │ └── depth: 0 + ├── @ LocalVariableReadNode (location: (33,12)-(33,14)) + │ ├── name: :ab + │ └── depth: 0 + ├── @ MatchWriteNode (location: (35,0)-(35,24)) + │ ├── call: + │ │ @ CallNode (location: (35,0)-(35,24)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ RegularExpressionNode (location: (35,0)-(35,18)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (35,0)-(35,1) = "/" + │ │ │ ├── content_loc: (35,1)-(35,17) = "(?<abc>)(?<abc>)" + │ │ │ ├── closing_loc: (35,17)-(35,18) = "/" + │ │ │ └── unescaped: "(?<abc>)(?<abc>)" + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :=~ + │ │ ├── message_loc: (35,19)-(35,21) = "=~" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (35,22)-(35,24)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (35,22)-(35,24)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (35,22)-(35,23) = "\"" + │ │ │ ├── content_loc: (35,23)-(35,23) = "" + │ │ │ ├── closing_loc: (35,23)-(35,24) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── targets: (length: 1) + │ └── @ LocalVariableTargetNode (location: (35,4)-(35,7)) + │ ├── name: :abc + │ └── depth: 0 + ├── @ LocalVariableReadNode (location: (35,26)-(35,29)) + │ ├── name: :abc + │ └── depth: 0 + ├── @ CallNode (location: (37,0)-(37,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (37,0)-(37,10)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (37,0)-(37,1) = "/" + │ │ ├── content_loc: (37,1)-(37,9) = "(?<a b>)" + │ │ ├── closing_loc: (37,9)-(37,10) = "/" + │ │ └── unescaped: "(?<a b>)" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (37,11)-(37,13) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (37,14)-(37,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (37,14)-(37,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (37,14)-(37,15) = "\"" + │ │ ├── content_loc: (37,15)-(37,15) = "" + │ │ ├── closing_loc: (37,15)-(37,16) = "\"" + │ │ └── unescaped: "" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ LocalVariableWriteNode (location: (39,0)-(39,5)) + │ ├── name: :a + │ ├── depth: 0 + │ ├── name_loc: (39,0)-(39,1) = "a" + │ ├── value: + │ │ @ IntegerNode (location: (39,4)-(39,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (39,2)-(39,3) = "=" + ├── @ CallNode (location: (40,0)-(40,24)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :tap + │ ├── message_loc: (40,0)-(40,3) = "tap" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (40,4)-(40,24)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (40,6)-(40,22)) + │ │ └── body: (length: 1) + │ │ └── @ MatchWriteNode (location: (40,6)-(40,22)) + │ │ ├── call: + │ │ │ @ CallNode (location: (40,6)-(40,22)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ RegularExpressionNode (location: (40,6)-(40,14)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (40,6)-(40,7) = "/" + │ │ │ │ ├── content_loc: (40,7)-(40,13) = "(?<a>)" + │ │ │ │ ├── closing_loc: (40,13)-(40,14) = "/" + │ │ │ │ └── unescaped: "(?<a>)" + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :=~ + │ │ │ ├── message_loc: (40,15)-(40,17) = "=~" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (40,18)-(40,22)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (40,18)-(40,22)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :to_s + │ │ │ │ ├── message_loc: (40,18)-(40,22) = "to_s" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── targets: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (40,10)-(40,11)) + │ │ ├── name: :a + │ │ └── depth: 1 + │ ├── opening_loc: (40,4)-(40,5) = "{" + │ └── closing_loc: (40,23)-(40,24) = "}" + ├── @ MatchWriteNode (location: (42,0)-(42,16)) + │ ├── call: + │ │ @ CallNode (location: (42,0)-(42,16)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ RegularExpressionNode (location: (42,0)-(42,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (42,0)-(42,1) = "/" + │ │ │ ├── content_loc: (42,1)-(42,9) = "(?<foo>)" + │ │ │ ├── closing_loc: (42,9)-(42,10) = "/" + │ │ │ └── unescaped: "(?<foo>)" + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :=~ + │ │ ├── message_loc: (42,11)-(42,13) = "=~" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (42,14)-(42,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (42,14)-(42,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (42,14)-(42,15) = "\"" + │ │ │ ├── content_loc: (42,15)-(42,15) = "" + │ │ │ ├── closing_loc: (42,15)-(42,16) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── targets: (length: 1) + │ └── @ LocalVariableTargetNode (location: (42,4)-(42,7)) + │ ├── name: :foo + │ └── depth: 0 + ├── @ CallNode (location: (43,0)-(43,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (43,0)-(43,10)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (43,0)-(43,1) = "/" + │ │ ├── content_loc: (43,1)-(43,9) = "(?<Foo>)" + │ │ ├── closing_loc: (43,9)-(43,10) = "/" + │ │ └── unescaped: "(?<Foo>)" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (43,11)-(43,13) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (43,14)-(43,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (43,14)-(43,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (43,14)-(43,15) = "\"" + │ │ ├── content_loc: (43,15)-(43,15) = "" + │ │ ├── closing_loc: (43,15)-(43,16) = "\"" + │ │ └── unescaped: "" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (45,0)-(45,10)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (45,0)-(45,1) = "/" + │ │ ├── content_loc: (45,1)-(45,9) = "(?<nil>)" + │ │ ├── closing_loc: (45,9)-(45,10) = "/" + │ │ └── unescaped: "(?<nil>)" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (45,11)-(45,13) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (45,14)-(45,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (45,14)-(45,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (45,14)-(45,15) = "\"" + │ │ ├── content_loc: (45,15)-(45,15) = "" + │ │ ├── closing_loc: (45,15)-(45,16) = "\"" + │ │ └── unescaped: "" + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ DefNode (location: (46,0)-(46,32)) + ├── name: :foo + ├── name_loc: (46,4)-(46,7) = "foo" + ├── receiver: ∅ + ├── parameters: + │ @ ParametersNode (location: (46,8)-(46,12)) + │ ├── requireds: (length: 0) + │ ├── optionals: (length: 0) + │ ├── rest: ∅ + │ ├── posts: (length: 0) + │ ├── keywords: (length: 1) + │ │ └── @ RequiredKeywordParameterNode (location: (46,8)-(46,12)) + │ │ ├── flags: ∅ + │ │ ├── name: :nil + │ │ └── name_loc: (46,8)-(46,12) = "nil:" + │ ├── keyword_rest: ∅ + │ └── block: ∅ + ├── body: + │ @ StatementsNode (location: (46,16)-(46,32)) + │ └── body: (length: 1) + │ └── @ MatchWriteNode (location: (46,16)-(46,32)) + │ ├── call: + │ │ @ CallNode (location: (46,16)-(46,32)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ RegularExpressionNode (location: (46,16)-(46,26)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (46,16)-(46,17) = "/" + │ │ │ ├── content_loc: (46,17)-(46,25) = "(?<nil>)" + │ │ │ ├── closing_loc: (46,25)-(46,26) = "/" + │ │ │ └── unescaped: "(?<nil>)" + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :=~ + │ │ ├── message_loc: (46,27)-(46,29) = "=~" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (46,30)-(46,32)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (46,30)-(46,32)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (46,30)-(46,31) = "\"" + │ │ │ ├── content_loc: (46,31)-(46,31) = "" + │ │ │ ├── closing_loc: (46,31)-(46,32) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── targets: (length: 1) + │ └── @ LocalVariableTargetNode (location: (46,20)-(46,23)) + │ ├── name: :nil + │ └── depth: 0 + ├── locals: [:nil] + ├── def_keyword_loc: (46,0)-(46,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: (46,7)-(46,8) = "(" + ├── rparen_loc: (46,12)-(46,13) = ")" + ├── equal_loc: (46,14)-(46,15) = "=" + └── end_keyword_loc: ∅ |