@ 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) = "(?bar)" │ │ │ │ │ ├── closing_loc: (11,13)-(11,14) = "/" │ │ │ │ │ └── unescaped: "(?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) = "(?)" │ │ │ ├── closing_loc: (33,3)-(33,4) = "/" │ │ │ └── unescaped: "(?)" │ │ ├── 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) = "(?)(?)" │ │ │ ├── closing_loc: (35,17)-(35,18) = "/" │ │ │ └── unescaped: "(?)(?)" │ │ ├── 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) = "(?)" │ │ ├── closing_loc: (37,9)-(37,10) = "/" │ │ └── unescaped: "(?)" │ ├── 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) = "(?)" │ │ │ │ ├── closing_loc: (40,13)-(40,14) = "/" │ │ │ │ └── unescaped: "(?)" │ │ │ ├── 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) = "(?)" │ │ │ ├── closing_loc: (42,9)-(42,10) = "/" │ │ │ └── unescaped: "(?)" │ │ ├── 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) = "(?)" │ │ ├── closing_loc: (43,9)-(43,10) = "/" │ │ └── unescaped: "(?)" │ ├── 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) = "(?)" │ │ ├── closing_loc: (45,9)-(45,10) = "/" │ │ └── unescaped: "(?)" │ ├── 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) = "(?)" │ │ │ ├── closing_loc: (46,25)-(46,26) = "/" │ │ │ └── unescaped: "(?)" │ │ ├── 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: ∅