diff options
Diffstat (limited to 'test/prism/snapshots/regex.txt')
-rw-r--r-- | test/prism/snapshots/regex.txt | 510 |
1 files changed, 0 insertions, 510 deletions
diff --git a/test/prism/snapshots/regex.txt b/test/prism/snapshots/regex.txt deleted file mode 100644 index d4d153e8d5..0000000000 --- a/test/prism/snapshots/regex.txt +++ /dev/null @@ -1,510 +0,0 @@ -@ 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: ∅ |