diff options
| author | Max Prokopiev <maxprokopiev@github.com> | 2024-01-24 21:08:33 +0100 |
|---|---|---|
| committer | git <svn-admin@ruby-lang.org> | 2024-01-24 20:32:02 +0000 |
| commit | e9f936df71b68515210b6040766987d1b94ec4df (patch) | |
| tree | fb132d1c384eac16e19be2a82bfb0c4408b7d8b4 | |
| parent | 91a5093c15f5fe5e51f0f5ba3183ea44688b49ea (diff) | |
[ruby/prism] Extract snippet into its own file and skip in TruffleRuby
https://github.com/ruby/prism/commit/12649ee74c
| -rw-r--r-- | test/prism/fixtures/emoji_method_calls.txt | 1 | ||||
| -rw-r--r-- | test/prism/fixtures/method_calls.txt | 2 | ||||
| -rw-r--r-- | test/prism/parse_test.rb | 2 | ||||
| -rw-r--r-- | test/prism/snapshots/method_calls.txt | 1563 |
4 files changed, 771 insertions, 797 deletions
diff --git a/test/prism/fixtures/emoji_method_calls.txt b/test/prism/fixtures/emoji_method_calls.txt new file mode 100644 index 0000000000..96d0daba33 --- /dev/null +++ b/test/prism/fixtures/emoji_method_calls.txt @@ -0,0 +1 @@ +foo.🌊 = 1 diff --git a/test/prism/fixtures/method_calls.txt b/test/prism/fixtures/method_calls.txt index ad70c70aa0..d30780771f 100644 --- a/test/prism/fixtures/method_calls.txt +++ b/test/prism/fixtures/method_calls.txt @@ -20,8 +20,6 @@ a::b c foo.bar = 1 -foo.🌊 = 1 - a? a(&block) diff --git a/test/prism/parse_test.rb b/test/prism/parse_test.rb index 6c5d125c3d..2624315008 100644 --- a/test/prism/parse_test.rb +++ b/test/prism/parse_test.rb @@ -87,7 +87,7 @@ module Prism relatives.each do |relative| # These fail on TruffleRuby due to a difference in Symbol#inspect: :测试 vs :"测试" - next if RUBY_ENGINE == "truffleruby" and %w[seattlerb/bug202.txt seattlerb/magic_encoding_comment.txt].include?(relative) + next if RUBY_ENGINE == "truffleruby" and %w[emoji_method_calls.txt seattlerb/bug202.txt seattlerb/magic_encoding_comment.txt].include?(relative) filepath = File.join(base, relative) snapshot = File.expand_path(File.join("snapshots", relative), __dir__) diff --git a/test/prism/snapshots/method_calls.txt b/test/prism/snapshots/method_calls.txt index 4a76fe5e13..ff6e0dd7df 100644 --- a/test/prism/snapshots/method_calls.txt +++ b/test/prism/snapshots/method_calls.txt @@ -1,8 +1,8 @@ -@ ProgramNode (location: (1,0)-(156,6)) +@ ProgramNode (location: (1,0)-(154,6)) ├── locals: [:foo] └── statements: - @ StatementsNode (location: (1,0)-(156,6)) - └── body: (length: 67) + @ StatementsNode (location: (1,0)-(154,6)) + └── body: (length: 66) ├── @ CallNode (location: (1,0)-(1,14)) │ ├── flags: ∅ │ ├── receiver: @@ -262,710 +262,685 @@ │ │ └── flags: decimal │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (23,0)-(23,12)) - │ ├── flags: attribute_write - │ ├── receiver: - │ │ @ CallNode (location: (23,0)-(23,3)) - │ │ ├── flags: variable_call, ignore_visibility - │ │ ├── receiver: ∅ - │ │ ├── call_operator_loc: ∅ - │ │ ├── name: :foo - │ │ ├── message_loc: (23,0)-(23,3) = "foo" - │ │ ├── opening_loc: ∅ - │ │ ├── arguments: ∅ - │ │ ├── closing_loc: ∅ - │ │ └── block: ∅ - │ ├── call_operator_loc: (23,3)-(23,4) = "." - │ ├── name: :🌊= - │ ├── message_loc: (23,4)-(23,8) = "🌊" - │ ├── opening_loc: ∅ - │ ├── arguments: - │ │ @ ArgumentsNode (location: (23,11)-(23,12)) - │ │ ├── flags: ∅ - │ │ └── arguments: (length: 1) - │ │ └── @ IntegerNode (location: (23,11)-(23,12)) - │ │ └── flags: decimal - │ ├── closing_loc: ∅ - │ └── block: ∅ - ├── @ CallNode (location: (25,0)-(25,2)) + ├── @ CallNode (location: (23,0)-(23,2)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a? - │ ├── message_loc: (25,0)-(25,2) = "a?" + │ ├── message_loc: (23,0)-(23,2) = "a?" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (27,0)-(27,8)) + ├── @ CallNode (location: (25,0)-(25,8)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (27,0)-(27,1) = "a" - │ ├── opening_loc: (27,1)-(27,2) = "(" + │ ├── message_loc: (25,0)-(25,1) = "a" + │ ├── opening_loc: (25,1)-(25,2) = "(" │ ├── arguments: ∅ - │ ├── closing_loc: (27,8)-(27,9) = ")" + │ ├── closing_loc: (25,8)-(25,9) = ")" │ └── block: - │ @ BlockArgumentNode (location: (27,2)-(27,8)) + │ @ BlockArgumentNode (location: (25,2)-(25,8)) │ ├── expression: - │ │ @ CallNode (location: (27,3)-(27,8)) + │ │ @ CallNode (location: (25,3)-(25,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :block - │ │ ├── message_loc: (27,3)-(27,8) = "block" + │ │ ├── message_loc: (25,3)-(25,8) = "block" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ └── operator_loc: (27,2)-(27,3) = "&" - ├── @ CallNode (location: (29,0)-(29,11)) + │ └── operator_loc: (25,2)-(25,3) = "&" + ├── @ CallNode (location: (27,0)-(27,11)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (29,0)-(29,1) = "a" - │ ├── opening_loc: (29,1)-(29,2) = "(" + │ ├── message_loc: (27,0)-(27,1) = "a" + │ ├── opening_loc: (27,1)-(27,2) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (29,2)-(29,10)) + │ │ @ ArgumentsNode (location: (27,2)-(27,10)) │ │ ├── flags: contains_keyword_splat │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (29,2)-(29,10)) + │ │ └── @ KeywordHashNode (location: (27,2)-(27,10)) │ │ ├── flags: ∅ │ │ └── elements: (length: 1) - │ │ └── @ AssocSplatNode (location: (29,2)-(29,10)) + │ │ └── @ AssocSplatNode (location: (27,2)-(27,10)) │ │ ├── value: - │ │ │ @ CallNode (location: (29,4)-(29,10)) + │ │ │ @ CallNode (location: (27,4)-(27,10)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :kwargs - │ │ │ ├── message_loc: (29,4)-(29,10) = "kwargs" + │ │ │ ├── message_loc: (27,4)-(27,10) = "kwargs" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── operator_loc: (29,2)-(29,4) = "**" - │ ├── closing_loc: (29,10)-(29,11) = ")" + │ │ └── operator_loc: (27,2)-(27,4) = "**" + │ ├── closing_loc: (27,10)-(27,11) = ")" │ └── block: ∅ - ├── @ CallNode (location: (31,0)-(31,5)) + ├── @ CallNode (location: (29,0)-(29,5)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (31,0)-(31,3)) + │ │ @ CallNode (location: (29,0)-(29,3)) │ │ ├── flags: ∅ │ │ ├── receiver: - │ │ │ @ CallNode (location: (31,0)-(31,1)) + │ │ │ @ CallNode (location: (29,0)-(29,1)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :a - │ │ │ ├── message_loc: (31,0)-(31,1) = "a" + │ │ │ ├── message_loc: (29,0)-(29,1) = "a" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ ├── call_operator_loc: (31,1)-(31,2) = "." + │ │ ├── call_operator_loc: (29,1)-(29,2) = "." │ │ ├── name: :b - │ │ ├── message_loc: (31,2)-(31,3) = "b" + │ │ ├── message_loc: (29,2)-(29,3) = "b" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (31,3)-(31,4) = "." + │ ├── call_operator_loc: (29,3)-(29,4) = "." │ ├── name: :c - │ ├── message_loc: (31,4)-(31,5) = "c" + │ ├── message_loc: (29,4)-(29,5) = "c" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (33,0)-(33,7)) + ├── @ CallNode (location: (31,0)-(31,7)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (33,0)-(33,1) = "a" - │ ├── opening_loc: (33,1)-(33,2) = "(" + │ ├── message_loc: (31,0)-(31,1) = "a" + │ ├── opening_loc: (31,1)-(31,2) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (33,2)-(33,6)) + │ │ @ ArgumentsNode (location: (31,2)-(31,6)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ CallNode (location: (33,2)-(33,3)) + │ │ ├── @ CallNode (location: (31,2)-(31,3)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :b - │ │ │ ├── message_loc: (33,2)-(33,3) = "b" + │ │ │ ├── message_loc: (31,2)-(31,3) = "b" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── @ CallNode (location: (33,5)-(33,6)) + │ │ └── @ CallNode (location: (31,5)-(31,6)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :c - │ │ ├── message_loc: (33,5)-(33,6) = "c" + │ │ ├── message_loc: (31,5)-(31,6) = "c" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── closing_loc: (33,6)-(33,7) = ")" + │ ├── closing_loc: (31,6)-(31,7) = ")" │ └── block: ∅ - ├── @ CallNode (location: (35,0)-(35,3)) + ├── @ CallNode (location: (33,0)-(33,3)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (35,0)-(35,1) = "a" - │ ├── opening_loc: (35,1)-(35,2) = "(" + │ ├── message_loc: (33,0)-(33,1) = "a" + │ ├── opening_loc: (33,1)-(33,2) = "(" │ ├── arguments: ∅ - │ ├── closing_loc: (35,2)-(35,3) = ")" + │ ├── closing_loc: (33,2)-(33,3) = ")" │ └── block: ∅ - ├── @ CallNode (location: (37,0)-(37,8)) + ├── @ CallNode (location: (35,0)-(35,8)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (37,0)-(37,1) = "a" - │ ├── opening_loc: (37,1)-(37,2) = "(" + │ ├── message_loc: (35,0)-(35,1) = "a" + │ ├── opening_loc: (35,1)-(35,2) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (37,2)-(37,7)) + │ │ @ ArgumentsNode (location: (35,2)-(35,7)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ SplatNode (location: (37,2)-(37,7)) - │ │ ├── operator_loc: (37,2)-(37,3) = "*" + │ │ └── @ SplatNode (location: (35,2)-(35,7)) + │ │ ├── operator_loc: (35,2)-(35,3) = "*" │ │ └── expression: - │ │ @ CallNode (location: (37,3)-(37,7)) + │ │ @ CallNode (location: (35,3)-(35,7)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :args - │ │ ├── message_loc: (37,3)-(37,7) = "args" + │ │ ├── message_loc: (35,3)-(35,7) = "args" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── closing_loc: (37,7)-(37,8) = ")" + │ ├── closing_loc: (35,7)-(35,8) = ")" │ └── block: ∅ - ├── @ CallNode (location: (39,0)-(39,6)) + ├── @ CallNode (location: (37,0)-(37,6)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :a - │ ├── message_loc: (39,0)-(39,1) = "a" + │ ├── message_loc: (37,0)-(37,1) = "a" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (39,2)-(39,6)) + │ │ @ ArgumentsNode (location: (37,2)-(37,6)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ CallNode (location: (39,2)-(39,3)) + │ │ ├── @ CallNode (location: (37,2)-(37,3)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :b - │ │ │ ├── message_loc: (39,2)-(39,3) = "b" + │ │ │ ├── message_loc: (37,2)-(37,3) = "b" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── @ CallNode (location: (39,5)-(39,6)) + │ │ └── @ CallNode (location: (37,5)-(37,6)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :c - │ │ ├── message_loc: (39,5)-(39,6) = "c" + │ │ ├── message_loc: (37,5)-(37,6) = "c" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (41,0)-(41,8)) + ├── @ CallNode (location: (39,0)-(39,8)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (41,0)-(41,1)) + │ │ @ CallNode (location: (39,0)-(39,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a - │ │ ├── message_loc: (41,0)-(41,1) = "a" + │ │ ├── message_loc: (39,0)-(39,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (41,1)-(41,2) = "." + │ ├── call_operator_loc: (39,1)-(39,2) = "." │ ├── name: :b - │ ├── message_loc: (41,2)-(41,3) = "b" + │ ├── message_loc: (39,2)-(39,3) = "b" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (41,4)-(41,8)) + │ │ @ ArgumentsNode (location: (39,4)-(39,8)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ CallNode (location: (41,4)-(41,5)) + │ │ ├── @ CallNode (location: (39,4)-(39,5)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :c - │ │ │ ├── message_loc: (41,4)-(41,5) = "c" + │ │ │ ├── message_loc: (39,4)-(39,5) = "c" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── @ CallNode (location: (41,7)-(41,8)) + │ │ └── @ CallNode (location: (39,7)-(39,8)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :d - │ │ ├── message_loc: (41,7)-(41,8) = "d" + │ │ ├── message_loc: (39,7)-(39,8) = "d" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ MultiWriteNode (location: (43,0)-(43,23)) + ├── @ MultiWriteNode (location: (41,0)-(41,23)) │ ├── lefts: (length: 2) - │ │ ├── @ CallTargetNode (location: (43,0)-(43,7)) + │ │ ├── @ CallTargetNode (location: (41,0)-(41,7)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: - │ │ │ │ @ CallNode (location: (43,0)-(43,3)) + │ │ │ │ @ CallNode (location: (41,0)-(41,3)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :foo - │ │ │ │ ├── message_loc: (43,0)-(43,3) = "foo" + │ │ │ │ ├── message_loc: (41,0)-(41,3) = "foo" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ - │ │ │ ├── call_operator_loc: (43,3)-(43,4) = "." + │ │ │ ├── call_operator_loc: (41,3)-(41,4) = "." │ │ │ ├── name: :foo= - │ │ │ └── message_loc: (43,4)-(43,7) = "foo" - │ │ └── @ CallTargetNode (location: (43,9)-(43,16)) + │ │ │ └── message_loc: (41,4)-(41,7) = "foo" + │ │ └── @ CallTargetNode (location: (41,9)-(41,16)) │ │ ├── flags: ∅ │ │ ├── receiver: - │ │ │ @ CallNode (location: (43,9)-(43,12)) + │ │ │ @ CallNode (location: (41,9)-(41,12)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar - │ │ │ ├── message_loc: (43,9)-(43,12) = "bar" + │ │ │ ├── message_loc: (41,9)-(41,12) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ ├── call_operator_loc: (43,12)-(43,13) = "." + │ │ ├── call_operator_loc: (41,12)-(41,13) = "." │ │ ├── name: :bar= - │ │ └── message_loc: (43,13)-(43,16) = "bar" + │ │ └── message_loc: (41,13)-(41,16) = "bar" │ ├── rest: ∅ │ ├── rights: (length: 0) │ ├── lparen_loc: ∅ │ ├── rparen_loc: ∅ - │ ├── operator_loc: (43,17)-(43,18) = "=" + │ ├── operator_loc: (41,17)-(41,18) = "=" │ └── value: - │ @ ArrayNode (location: (43,19)-(43,23)) + │ @ ArrayNode (location: (41,19)-(41,23)) │ ├── flags: ∅ │ ├── elements: (length: 2) - │ │ ├── @ IntegerNode (location: (43,19)-(43,20)) + │ │ ├── @ IntegerNode (location: (41,19)-(41,20)) │ │ │ └── flags: decimal - │ │ └── @ IntegerNode (location: (43,22)-(43,23)) + │ │ └── @ IntegerNode (location: (41,22)-(41,23)) │ │ └── flags: decimal │ ├── opening_loc: ∅ │ └── closing_loc: ∅ - ├── @ CallNode (location: (45,0)-(45,4)) + ├── @ CallNode (location: (43,0)-(43,4)) │ ├── flags: safe_navigation │ ├── receiver: - │ │ @ CallNode (location: (45,0)-(45,1)) + │ │ @ CallNode (location: (43,0)-(43,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a - │ │ ├── message_loc: (45,0)-(45,1) = "a" + │ │ ├── message_loc: (43,0)-(43,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (45,1)-(45,3) = "&." + │ ├── call_operator_loc: (43,1)-(43,3) = "&." │ ├── name: :b - │ ├── message_loc: (45,3)-(45,4) = "b" + │ ├── message_loc: (43,3)-(43,4) = "b" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (47,0)-(47,5)) + ├── @ CallNode (location: (45,0)-(45,5)) │ ├── flags: safe_navigation │ ├── receiver: - │ │ @ CallNode (location: (47,0)-(47,1)) + │ │ @ CallNode (location: (45,0)-(45,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a - │ │ ├── message_loc: (47,0)-(47,1) = "a" + │ │ ├── message_loc: (45,0)-(45,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (47,1)-(47,3) = "&." + │ ├── call_operator_loc: (45,1)-(45,3) = "&." │ ├── name: :call │ ├── message_loc: ∅ - │ ├── opening_loc: (47,3)-(47,4) = "(" + │ ├── opening_loc: (45,3)-(45,4) = "(" │ ├── arguments: ∅ - │ ├── closing_loc: (47,4)-(47,5) = ")" + │ ├── closing_loc: (45,4)-(45,5) = ")" │ └── block: ∅ - ├── @ CallNode (location: (49,0)-(49,7)) + ├── @ CallNode (location: (47,0)-(47,7)) │ ├── flags: safe_navigation │ ├── receiver: - │ │ @ CallNode (location: (49,0)-(49,1)) + │ │ @ CallNode (location: (47,0)-(47,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a - │ │ ├── message_loc: (49,0)-(49,1) = "a" + │ │ ├── message_loc: (47,0)-(47,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (49,1)-(49,3) = "&." + │ ├── call_operator_loc: (47,1)-(47,3) = "&." │ ├── name: :b - │ ├── message_loc: (49,3)-(49,4) = "b" - │ ├── opening_loc: (49,4)-(49,5) = "(" + │ ├── message_loc: (47,3)-(47,4) = "b" + │ ├── opening_loc: (47,4)-(47,5) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (49,5)-(49,6)) + │ │ @ ArgumentsNode (location: (47,5)-(47,6)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ CallNode (location: (49,5)-(49,6)) + │ │ └── @ CallNode (location: (47,5)-(47,6)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :c - │ │ ├── message_loc: (49,5)-(49,6) = "c" + │ │ ├── message_loc: (47,5)-(47,6) = "c" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── closing_loc: (49,6)-(49,7) = ")" + │ ├── closing_loc: (47,6)-(47,7) = ")" │ └── block: ∅ - ├── @ CallNode (location: (51,0)-(51,6)) + ├── @ CallNode (location: (49,0)-(49,6)) │ ├── flags: safe_navigation │ ├── receiver: - │ │ @ CallNode (location: (51,0)-(51,1)) + │ │ @ CallNode (location: (49,0)-(49,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :a - │ │ ├── message_loc: (51,0)-(51,1) = "a" + │ │ ├── message_loc: (49,0)-(49,1) = "a" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (51,1)-(51,3) = "&." + │ ├── call_operator_loc: (49,1)-(49,3) = "&." │ ├── name: :b - │ ├── message_loc: (51,3)-(51,4) = "b" - │ ├── opening_loc: (51,4)-(51,5) = "(" + │ ├── message_loc: (49,3)-(49,4) = "b" + │ ├── opening_loc: (49,4)-(49,5) = "(" │ ├── arguments: ∅ - │ ├── closing_loc: (51,5)-(51,6) = ")" + │ ├── closing_loc: (49,5)-(49,6) = ")" │ └── block: ∅ - ├── @ IfNode (location: (53,0)-(53,33)) - │ ├── if_keyword_loc: (53,11)-(53,13) = "if" + ├── @ IfNode (location: (51,0)-(51,33)) + │ ├── if_keyword_loc: (51,11)-(51,13) = "if" │ ├── predicate: - │ │ @ AndNode (location: (53,14)-(53,33)) + │ │ @ AndNode (location: (51,14)-(51,33)) │ │ ├── left: - │ │ │ @ OrNode (location: (53,14)-(53,25)) + │ │ │ @ OrNode (location: (51,14)-(51,25)) │ │ │ ├── left: - │ │ │ │ @ CallNode (location: (53,14)-(53,18)) + │ │ │ │ @ CallNode (location: (51,14)-(51,18)) │ │ │ │ ├── flags: ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :bar? - │ │ │ │ ├── message_loc: (53,14)-(53,18) = "bar?" + │ │ │ │ ├── message_loc: (51,14)-(51,18) = "bar?" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── right: - │ │ │ │ @ CallNode (location: (53,22)-(53,25)) + │ │ │ │ @ CallNode (location: (51,22)-(51,25)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :baz - │ │ │ │ ├── message_loc: (53,22)-(53,25) = "baz" + │ │ │ │ ├── message_loc: (51,22)-(51,25) = "baz" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ - │ │ │ └── operator_loc: (53,19)-(53,21) = "or" + │ │ │ └── operator_loc: (51,19)-(51,21) = "or" │ │ ├── right: - │ │ │ @ CallNode (location: (53,30)-(53,33)) + │ │ │ @ CallNode (location: (51,30)-(51,33)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :qux - │ │ │ ├── message_loc: (53,30)-(53,33) = "qux" + │ │ │ ├── message_loc: (51,30)-(51,33) = "qux" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── operator_loc: (53,26)-(53,29) = "and" + │ │ └── operator_loc: (51,26)-(51,29) = "and" │ ├── then_keyword_loc: ∅ │ ├── statements: - │ │ @ StatementsNode (location: (53,0)-(53,10)) + │ │ @ StatementsNode (location: (51,0)-(51,10)) │ │ └── body: (length: 1) - │ │ └── @ CallNode (location: (53,0)-(53,10)) + │ │ └── @ CallNode (location: (51,0)-(51,10)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo - │ │ ├── message_loc: (53,0)-(53,3) = "foo" + │ │ ├── message_loc: (51,0)-(51,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: - │ │ │ @ ArgumentsNode (location: (53,4)-(53,10)) + │ │ │ @ ArgumentsNode (location: (51,4)-(51,10)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 2) - │ │ │ ├── @ SymbolNode (location: (53,4)-(53,6)) + │ │ │ ├── @ SymbolNode (location: (51,4)-(51,6)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (53,4)-(53,5) = ":" - │ │ │ │ ├── value_loc: (53,5)-(53,6) = "a" + │ │ │ │ ├── opening_loc: (51,4)-(51,5) = ":" + │ │ │ │ ├── value_loc: (51,5)-(51,6) = "a" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "a" - │ │ │ └── @ SymbolNode (location: (53,8)-(53,10)) + │ │ │ └── @ SymbolNode (location: (51,8)-(51,10)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (53,8)-(53,9) = ":" - │ │ │ ├── value_loc: (53,9)-(53,10) = "b" + │ │ │ ├── opening_loc: (51,8)-(51,9) = ":" + │ │ │ ├── value_loc: (51,9)-(51,10) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── consequent: ∅ │ └── end_keyword_loc: ∅ - ├── @ CallNode (location: (55,0)-(58,1)) + ├── @ CallNode (location: (53,0)-(56,1)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (55,0)-(55,3) = "foo" - │ ├── opening_loc: (55,3)-(55,4) = "(" + │ ├── message_loc: (53,0)-(53,3) = "foo" + │ ├── opening_loc: (53,3)-(53,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (55,4)-(57,4)) + │ │ @ ArgumentsNode (location: (53,4)-(55,4)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (55,4)-(55,6)) + │ │ ├── @ SymbolNode (location: (53,4)-(53,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (55,4)-(55,5) = ":" - │ │ │ ├── value_loc: (55,5)-(55,6) = "a" + │ │ │ ├── opening_loc: (53,4)-(53,5) = ":" + │ │ │ ├── value_loc: (53,5)-(53,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ SymbolNode (location: (57,2)-(57,4)) + │ │ └── @ SymbolNode (location: (55,2)-(55,4)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (57,2)-(57,3) = ":" - │ │ ├── value_loc: (57,3)-(57,4) = "b" + │ │ ├── opening_loc: (55,2)-(55,3) = ":" + │ │ ├── value_loc: (55,3)-(55,4) = "b" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "b" - │ ├── closing_loc: (58,0)-(58,1) = ")" + │ ├── closing_loc: (56,0)-(56,1) = ")" │ └── block: ∅ - ├── @ CallNode (location: (60,0)-(60,10)) + ├── @ CallNode (location: (58,0)-(58,10)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (60,0)-(60,3) = "foo" - │ ├── opening_loc: (60,3)-(60,4) = "(" + │ ├── message_loc: (58,0)-(58,3) = "foo" + │ ├── opening_loc: (58,3)-(58,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (60,4)-(60,9)) + │ │ @ ArgumentsNode (location: (58,4)-(58,9)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ SplatNode (location: (60,4)-(60,9)) - │ │ ├── operator_loc: (60,4)-(60,5) = "*" + │ │ └── @ SplatNode (location: (58,4)-(58,9)) + │ │ ├── operator_loc: (58,4)-(58,5) = "*" │ │ └── expression: - │ │ @ CallNode (location: (60,5)-(60,9)) + │ │ @ CallNode (location: (58,5)-(58,9)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :rest - │ │ ├── message_loc: (60,5)-(60,9) = "rest" + │ │ ├── message_loc: (58,5)-(58,9) = "rest" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── closing_loc: (60,9)-(60,10) = ")" + │ ├── closing_loc: (58,9)-(58,10) = ")" │ └── block: ∅ - ├── @ CallNode (location: (62,0)-(62,39)) + ├── @ CallNode (location: (60,0)-(60,39)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (62,0)-(62,3) = "foo" - │ ├── opening_loc: (62,3)-(62,4) = "(" + │ ├── message_loc: (60,0)-(60,3) = "foo" + │ ├── opening_loc: (60,3)-(60,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (62,4)-(62,32)) + │ │ @ ArgumentsNode (location: (60,4)-(60,32)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (62,4)-(62,6)) + │ │ ├── @ SymbolNode (location: (60,4)-(60,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (62,4)-(62,5) = ":" - │ │ │ ├── value_loc: (62,5)-(62,6) = "a" + │ │ │ ├── opening_loc: (60,4)-(60,5) = ":" + │ │ │ ├── value_loc: (60,5)-(60,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ KeywordHashNode (location: (62,8)-(62,32)) + │ │ └── @ KeywordHashNode (location: (60,8)-(60,32)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 2) - │ │ ├── @ AssocNode (location: (62,8)-(62,22)) + │ │ ├── @ AssocNode (location: (60,8)-(60,22)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (62,8)-(62,10)) + │ │ │ │ @ SymbolNode (location: (60,8)-(60,10)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (62,8)-(62,9) = ":" - │ │ │ │ ├── value_loc: (62,9)-(62,10) = "h" + │ │ │ │ ├── opening_loc: (60,8)-(60,9) = ":" + │ │ │ │ ├── value_loc: (60,9)-(60,10) = "h" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "h" │ │ │ ├── value: - │ │ │ │ @ ArrayNode (location: (62,14)-(62,22)) + │ │ │ │ @ ArrayNode (location: (60,14)-(60,22)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── elements: (length: 2) - │ │ │ │ │ ├── @ SymbolNode (location: (62,15)-(62,17)) + │ │ │ │ │ ├── @ SymbolNode (location: (60,15)-(60,17)) │ │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ │ ├── opening_loc: (62,15)-(62,16) = ":" - │ │ │ │ │ │ ├── value_loc: (62,16)-(62,17) = "x" + │ │ │ │ │ │ ├── opening_loc: (60,15)-(60,16) = ":" + │ │ │ │ │ │ ├── value_loc: (60,16)-(60,17) = "x" │ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ └── unescaped: "x" - │ │ │ │ │ └── @ SymbolNode (location: (62,19)-(62,21)) + │ │ │ │ │ └── @ SymbolNode (location: (60,19)-(60,21)) │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ ├── opening_loc: (62,19)-(62,20) = ":" - │ │ │ │ │ ├── value_loc: (62,20)-(62,21) = "y" + │ │ │ │ │ ├── opening_loc: (60,19)-(60,20) = ":" + │ │ │ │ │ ├── value_loc: (60,20)-(60,21) = "y" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "y" - │ │ │ │ ├── opening_loc: (62,14)-(62,15) = "[" - │ │ │ │ └── closing_loc: (62,21)-(62,22) = "]" - │ │ │ └── operator_loc: (62,11)-(62,13) = "=>" - │ │ └── @ AssocNode (location: (62,24)-(62,32)) + │ │ │ │ ├── opening_loc: (60,14)-(60,15) = "[" + │ │ │ │ └── closing_loc: (60,21)-(60,22) = "]" + │ │ │ └── operator_loc: (60,11)-(60,13) = "=>" + │ │ └── @ AssocNode (location: (60,24)-(60,32)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (62,24)-(62,26)) + │ │ │ @ SymbolNode (location: (60,24)-(60,26)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (62,24)-(62,25) = ":" - │ │ │ ├── value_loc: (62,25)-(62,26) = "a" + │ │ │ ├── opening_loc: (60,24)-(60,25) = ":" + │ │ │ ├── value_loc: (60,25)-(60,26) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" │ │ ├── value: - │ │ │ @ SymbolNode (location: (62,30)-(62,32)) + │ │ │ @ SymbolNode (location: (60,30)-(60,32)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (62,30)-(62,31) = ":" - │ │ │ ├── value_loc: (62,31)-(62,32) = "b" + │ │ │ ├── opening_loc: (60,30)-(60,31) = ":" + │ │ │ ├── value_loc: (60,31)-(60,32) = "b" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "b" - │ │ └── operator_loc: (62,27)-(62,29) = "=>" - │ ├── closing_loc: (62,39)-(62,40) = ")" + │ │ └── operator_loc: (60,27)-(60,29) = "=>" + │ ├── closing_loc: (60,39)-(60,40) = ")" │ └── block: - │ @ BlockArgumentNode (location: (62,34)-(62,39)) + │ @ BlockArgumentNode (location: (60,34)-(60,39)) │ ├── expression: - │ │ @ SymbolNode (location: (62,35)-(62,39)) + │ │ @ SymbolNode (location: (60,35)-(60,39)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (62,35)-(62,36) = ":" - │ │ ├── value_loc: (62,36)-(62,39) = "bar" + │ │ ├── opening_loc: (60,35)-(60,36) = ":" + │ │ ├── value_loc: (60,36)-(60,39) = "bar" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "bar" - │ └── operator_loc: (62,34)-(62,35) = "&" - ├── @ CallNode (location: (64,0)-(64,49)) + │ └── operator_loc: (60,34)-(60,35) = "&" + ├── @ CallNode (location: (62,0)-(62,49)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :hi - │ ├── message_loc: (64,0)-(64,2) = "hi" + │ ├── message_loc: (62,0)-(62,2) = "hi" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (64,3)-(64,49)) + │ │ @ ArgumentsNode (location: (62,3)-(62,49)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ IntegerNode (location: (64,3)-(64,6)) + │ │ ├── @ IntegerNode (location: (62,3)-(62,6)) │ │ │ └── flags: decimal - │ │ └── @ HashNode (location: (64,8)-(64,49)) - │ │ ├── opening_loc: (64,8)-(64,9) = "{" + │ │ └── @ HashNode (location: (62,8)-(62,49)) + │ │ ├── opening_loc: (62,8)-(62,9) = "{" │ │ ├── elements: (length: 3) - │ │ │ ├── @ AssocNode (location: (64,10)-(64,27)) + │ │ │ ├── @ AssocNode (location: (62,10)-(62,27)) │ │ │ │ ├── key: - │ │ │ │ │ @ SymbolNode (location: (64,10)-(64,16)) + │ │ │ │ │ @ SymbolNode (location: (62,10)-(62,16)) │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ ├── opening_loc: (64,10)-(64,11) = ":" - │ │ │ │ │ ├── value_loc: (64,11)-(64,16) = "there" + │ │ │ │ │ ├── opening_loc: (62,10)-(62,11) = ":" + │ │ │ │ │ ├── value_loc: (62,11)-(62,16) = "there" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "there" │ │ │ │ ├── value: - │ │ │ │ │ @ SymbolNode (location: (64,20)-(64,27)) + │ │ │ │ │ @ SymbolNode (location: (62,20)-(62,27)) │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ ├── opening_loc: (64,20)-(64,21) = ":" - │ │ │ │ │ ├── value_loc: (64,21)-(64,27) = "friend" + │ │ │ │ │ ├── opening_loc: (62,20)-(62,21) = ":" + │ │ │ │ │ ├── value_loc: (62,21)-(62,27) = "friend" │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── unescaped: "friend" - │ │ │ │ └── operator_loc: (64,17)-(64,19) = "=>" - │ │ │ ├── @ AssocSplatNode (location: (64,29)-(64,33)) + │ │ │ │ └── operator_loc: (62,17)-(62,19) = "=>" + │ │ │ ├── @ AssocSplatNode (location: (62,29)-(62,33)) │ │ │ │ ├── value: - │ │ │ │ │ @ HashNode (location: (64,31)-(64,33)) - │ │ │ │ │ ├── opening_loc: (64,31)-(64,32) = "{" + │ │ │ │ │ @ HashNode (location: (62,31)-(62,33)) + │ │ │ │ │ ├── opening_loc: (62,31)-(62,32) = "{" │ │ │ │ │ ├── elements: (length: 0) - │ │ │ │ │ └── closing_loc: (64,32)-(64,33) = "}" - │ │ │ │ └── operator_loc: (64,29)-(64,31) = "**" - │ │ │ └── @ AssocNode (location: (64,35)-(64,47)) + │ │ │ │ │ └── closing_loc: (62,32)-(62,33) = "}" + │ │ │ │ └── operator_loc: (62,29)-(62,31) = "**" + │ │ │ └── @ AssocNode (location: (62,35)-(62,47)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (64,35)-(64,42)) + │ │ │ │ @ SymbolNode (location: (62,35)-(62,42)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: ∅ - │ │ │ │ ├── value_loc: (64,35)-(64,41) = "whatup" - │ │ │ │ ├── closing_loc: (64,41)-(64,42) = ":" + │ │ │ │ ├── value_loc: (62,35)-(62,41) = "whatup" + │ │ │ │ ├── closing_loc: (62,41)-(62,42) = ":" │ │ │ │ └── unescaped: "whatup" │ │ │ ├── value: - │ │ │ │ @ SymbolNode (location: (64,43)-(64,47)) + │ │ │ │ @ SymbolNode (location: (62,43)-(62,47)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (64,43)-(64,44) = ":" - │ │ │ │ ├── value_loc: (64,44)-(64,47) = "dog" + │ │ │ │ ├── opening_loc: (62,43)-(62,44) = ":" + │ │ │ │ ├── value_loc: (62,44)-(62,47) = "dog" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "dog" │ │ │ └── operator_loc: ∅ - │ │ └── closing_loc: (64,48)-(64,49) = "}" + │ │ └── closing_loc: (62,48)-(62,49) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (66,0)-(66,36)) + ├── @ CallNode (location: (64,0)-(64,36)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (66,0)-(66,3) = "foo" + │ ├── message_loc: (64,0)-(64,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (66,4)-(66,15)) + │ │ @ ArgumentsNode (location: (64,4)-(64,15)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (66,4)-(66,6)) + │ │ ├── @ SymbolNode (location: (64,4)-(64,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (66,4)-(66,5) = ":" - │ │ │ ├── value_loc: (66,5)-(66,6) = "a" + │ │ │ ├── opening_loc: (64,4)-(64,5) = ":" + │ │ │ ├── value_loc: (64,5)-(64,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ KeywordHashNode (location: (66,8)-(66,15)) + │ │ └── @ KeywordHashNode (location: (64,8)-(64,15)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (66,8)-(66,15)) + │ │ └── @ AssocNode (location: (64,8)-(64,15)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (66,8)-(66,10)) + │ │ │ @ SymbolNode (location: (64,8)-(64,10)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (66,8)-(66,9) = "b" - │ │ │ ├── closing_loc: (66,9)-(66,10) = ":" + │ │ │ ├── value_loc: (64,8)-(64,9) = "b" + │ │ │ ├── closing_loc: (64,9)-(64,10) = ":" │ │ │ └── unescaped: "b" │ │ ├── value: - │ │ │ @ TrueNode (location: (66,11)-(66,15)) + │ │ │ @ TrueNode (location: (64,11)-(64,15)) │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: - │ @ BlockNode (location: (66,16)-(66,36)) + │ @ BlockNode (location: (64,16)-(64,36)) │ ├── locals: [:a, :b] │ ├── locals_body_index: 2 │ ├── parameters: - │ │ @ BlockParametersNode (location: (66,19)-(66,25)) + │ │ @ BlockParametersNode (location: (64,19)-(64,25)) │ │ ├── parameters: - │ │ │ @ ParametersNode (location: (66,20)-(66,24)) + │ │ │ @ ParametersNode (location: (64,20)-(64,24)) │ │ │ ├── requireds: (length: 2) - │ │ │ │ ├── @ RequiredParameterNode (location: (66,20)-(66,21)) + │ │ │ │ ├── @ RequiredParameterNode (location: (64,20)-(64,21)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ └── name: :a - │ │ │ │ └── @ RequiredParameterNode (location: (66,23)-(66,24)) + │ │ │ │ └── @ RequiredParameterNode (location: (64,23)-(64,24)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── name: :b │ │ │ ├── optionals: (length: 0) @@ -975,486 +950,513 @@ │ │ │ ├── keyword_rest: ∅ │ │ │ └── block: ∅ │ │ ├── locals: (length: 0) - │ │ ├── opening_loc: (66,19)-(66,20) = "|" - │ │ └── closing_loc: (66,24)-(66,25) = "|" + │ │ ├── opening_loc: (64,19)-(64,20) = "|" + │ │ └── closing_loc: (64,24)-(64,25) = "|" │ ├── body: - │ │ @ StatementsNode (location: (66,26)-(66,32)) + │ │ @ StatementsNode (location: (64,26)-(64,32)) │ │ └── body: (length: 1) - │ │ └── @ CallNode (location: (66,26)-(66,32)) + │ │ └── @ CallNode (location: (64,26)-(64,32)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :puts - │ │ ├── message_loc: (66,26)-(66,30) = "puts" + │ │ ├── message_loc: (64,26)-(64,30) = "puts" │ │ ├── opening_loc: ∅ │ │ ├── arguments: - │ │ │ @ ArgumentsNode (location: (66,31)-(66,32)) + │ │ │ @ ArgumentsNode (location: (64,31)-(64,32)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 1) - │ │ │ └── @ LocalVariableReadNode (location: (66,31)-(66,32)) + │ │ │ └── @ LocalVariableReadNode (location: (64,31)-(64,32)) │ │ │ ├── name: :a │ │ │ └── depth: 0 │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── opening_loc: (66,16)-(66,18) = "do" - │ └── closing_loc: (66,33)-(66,36) = "end" - ├── @ CallNode (location: (68,0)-(68,17)) + │ ├── opening_loc: (64,16)-(64,18) = "do" + │ └── closing_loc: (64,33)-(64,36) = "end" + ├── @ CallNode (location: (66,0)-(66,17)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :hi - │ ├── message_loc: (68,0)-(68,2) = "hi" + │ ├── message_loc: (66,0)-(66,2) = "hi" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (68,3)-(68,17)) + │ │ @ ArgumentsNode (location: (66,3)-(66,17)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (68,3)-(68,17)) + │ │ └── @ KeywordHashNode (location: (66,3)-(66,17)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (68,3)-(68,17)) + │ │ └── @ AssocNode (location: (66,3)-(66,17)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (68,3)-(68,9)) + │ │ │ @ SymbolNode (location: (66,3)-(66,9)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (68,3)-(68,8) = "there" - │ │ │ ├── closing_loc: (68,8)-(68,9) = ":" + │ │ │ ├── value_loc: (66,3)-(66,8) = "there" + │ │ │ ├── closing_loc: (66,8)-(66,9) = ":" │ │ │ └── unescaped: "there" │ │ ├── value: - │ │ │ @ SymbolNode (location: (68,10)-(68,17)) + │ │ │ @ SymbolNode (location: (66,10)-(66,17)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (68,10)-(68,11) = ":" - │ │ │ ├── value_loc: (68,11)-(68,17) = "friend" + │ │ │ ├── opening_loc: (66,10)-(66,11) = ":" + │ │ │ ├── value_loc: (66,11)-(66,17) = "friend" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "friend" │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (70,0)-(70,40)) + ├── @ CallNode (location: (68,0)-(68,40)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :hi - │ ├── message_loc: (70,0)-(70,2) = "hi" + │ ├── message_loc: (68,0)-(68,2) = "hi" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (70,3)-(70,40)) + │ │ @ ArgumentsNode (location: (68,3)-(68,40)) │ │ ├── flags: contains_keyword_splat │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (70,3)-(70,40)) + │ │ └── @ KeywordHashNode (location: (68,3)-(68,40)) │ │ ├── flags: ∅ │ │ └── elements: (length: 3) - │ │ ├── @ AssocNode (location: (70,3)-(70,20)) + │ │ ├── @ AssocNode (location: (68,3)-(68,20)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (70,3)-(70,9)) + │ │ │ │ @ SymbolNode (location: (68,3)-(68,9)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (70,3)-(70,4) = ":" - │ │ │ │ ├── value_loc: (70,4)-(70,9) = "there" + │ │ │ │ ├── opening_loc: (68,3)-(68,4) = ":" + │ │ │ │ ├── value_loc: (68,4)-(68,9) = "there" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "there" │ │ │ ├── value: - │ │ │ │ @ SymbolNode (location: (70,13)-(70,20)) + │ │ │ │ @ SymbolNode (location: (68,13)-(68,20)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (70,13)-(70,14) = ":" - │ │ │ │ ├── value_loc: (70,14)-(70,20) = "friend" + │ │ │ │ ├── opening_loc: (68,13)-(68,14) = ":" + │ │ │ │ ├── value_loc: (68,14)-(68,20) = "friend" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "friend" - │ │ │ └── operator_loc: (70,10)-(70,12) = "=>" - │ │ ├── @ AssocSplatNode (location: (70,22)-(70,26)) + │ │ │ └── operator_loc: (68,10)-(68,12) = "=>" + │ │ ├── @ AssocSplatNode (location: (68,22)-(68,26)) │ │ │ ├── value: - │ │ │ │ @ HashNode (location: (70,24)-(70,26)) - │ │ │ │ ├── opening_loc: (70,24)-(70,25) = "{" + │ │ │ │ @ HashNode (location: (68,24)-(68,26)) + │ │ │ │ ├── opening_loc: (68,24)-(68,25) = "{" │ │ │ │ ├── elements: (length: 0) - │ │ │ │ └── closing_loc: (70,25)-(70,26) = "}" - │ │ │ └── operator_loc: (70,22)-(70,24) = "**" - │ │ └── @ AssocNode (location: (70,28)-(70,40)) + │ │ │ │ └── closing_loc: (68,25)-(68,26) = "}" + │ │ │ └── operator_loc: (68,22)-(68,24) = "**" + │ │ └── @ AssocNode (location: (68,28)-(68,40)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (70,28)-(70,35)) + │ │ │ @ SymbolNode (location: (68,28)-(68,35)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (70,28)-(70,34) = "whatup" - │ │ │ ├── closing_loc: (70,34)-(70,35) = ":" + │ │ │ ├── value_loc: (68,28)-(68,34) = "whatup" + │ │ │ ├── closing_loc: (68,34)-(68,35) = ":" │ │ │ └── unescaped: "whatup" │ │ ├── value: - │ │ │ @ SymbolNode (location: (70,36)-(70,40)) + │ │ │ @ SymbolNode (location: (68,36)-(68,40)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (70,36)-(70,37) = ":" - │ │ │ ├── value_loc: (70,37)-(70,40) = "dog" + │ │ │ ├── opening_loc: (68,36)-(68,37) = ":" + │ │ │ ├── value_loc: (68,37)-(68,40) = "dog" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "dog" │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (72,0)-(72,41)) + ├── @ CallNode (location: (70,0)-(70,41)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :hi - │ ├── message_loc: (72,0)-(72,2) = "hi" - │ ├── opening_loc: (72,2)-(72,3) = "(" + │ ├── message_loc: (70,0)-(70,2) = "hi" + │ ├── opening_loc: (70,2)-(70,3) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (72,3)-(72,40)) + │ │ @ ArgumentsNode (location: (70,3)-(70,40)) │ │ ├── flags: contains_keyword_splat │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (72,3)-(72,40)) + │ │ └── @ KeywordHashNode (location: (70,3)-(70,40)) │ │ ├── flags: ∅ │ │ └── elements: (length: 3) - │ │ ├── @ AssocNode (location: (72,3)-(72,20)) + │ │ ├── @ AssocNode (location: (70,3)-(70,20)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (72,3)-(72,9)) + │ │ │ │ @ SymbolNode (location: (70,3)-(70,9)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (72,3)-(72,4) = ":" - │ │ │ │ ├── value_loc: (72,4)-(72,9) = "there" + │ │ │ │ ├── opening_loc: (70,3)-(70,4) = ":" + │ │ │ │ ├── value_loc: (70,4)-(70,9) = "there" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "there" │ │ │ ├── value: - │ │ │ │ @ SymbolNode (location: (72,13)-(72,20)) + │ │ │ │ @ SymbolNode (location: (70,13)-(70,20)) │ │ │ │ ├── flags: ∅ - │ │ │ │ ├── opening_loc: (72,13)-(72,14) = ":" - │ │ │ │ ├── value_loc: (72,14)-(72,20) = "friend" + │ │ │ │ ├── opening_loc: (70,13)-(70,14) = ":" + │ │ │ │ ├── value_loc: (70,14)-(70,20) = "friend" │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── unescaped: "friend" - │ │ │ └── operator_loc: (72,10)-(72,12) = "=>" - │ │ ├── @ AssocSplatNode (location: (72,22)-(72,26)) + │ │ │ └── operator_loc: (70,10)-(70,12) = "=>" + │ │ ├── @ AssocSplatNode (location: (70,22)-(70,26)) │ │ │ ├── value: - │ │ │ │ @ HashNode (location: (72,24)-(72,26)) - │ │ │ │ ├── opening_loc: (72,24)-(72,25) = "{" + │ │ │ │ @ HashNode (location: (70,24)-(70,26)) + │ │ │ │ ├── opening_loc: (70,24)-(70,25) = "{" │ │ │ │ ├── elements: (length: 0) - │ │ │ │ └── closing_loc: (72,25)-(72,26) = "}" - │ │ │ └── operator_loc: (72,22)-(72,24) = "**" - │ │ └── @ AssocNode (location: (72,28)-(72,40)) + │ │ │ │ └── closing_loc: (70,25)-(70,26) = "}" + │ │ │ └── operator_loc: (70,22)-(70,24) = "**" + │ │ └── @ AssocNode (location: (70,28)-(70,40)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (72,28)-(72,35)) + │ │ │ @ SymbolNode (location: (70,28)-(70,35)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (72,28)-(72,34) = "whatup" - │ │ │ ├── closing_loc: (72,34)-(72,35) = ":" + │ │ │ ├── value_loc: (70,28)-(70,34) = "whatup" + │ │ │ ├── closing_loc: (70,34)-(70,35) = ":" │ │ │ └── unescaped: "whatup" │ │ ├── value: - │ │ │ @ SymbolNode (location: (72,36)-(72,40)) + │ │ │ @ SymbolNode (location: (70,36)-(70,40)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (72,36)-(72,37) = ":" - │ │ │ ├── value_loc: (72,37)-(72,40) = "dog" + │ │ │ ├── opening_loc: (70,36)-(70,37) = ":" + │ │ │ ├── value_loc: (70,37)-(70,40) = "dog" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "dog" │ │ └── operator_loc: ∅ - │ ├── closing_loc: (72,40)-(72,41) = ")" + │ ├── closing_loc: (70,40)-(70,41) = ")" │ └── block: ∅ - ├── @ CallNode (location: (74,0)-(74,35)) + ├── @ CallNode (location: (72,0)-(72,35)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (74,0)-(74,3) = "foo" - │ ├── opening_loc: (74,3)-(74,4) = "(" + │ ├── message_loc: (72,0)-(72,3) = "foo" + │ ├── opening_loc: (72,3)-(72,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (74,4)-(74,26)) + │ │ @ ArgumentsNode (location: (72,4)-(72,26)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ HashNode (location: (74,4)-(74,26)) - │ │ ├── opening_loc: (74,4)-(74,5) = "{" + │ │ └── @ HashNode (location: (72,4)-(72,26)) + │ │ ├── opening_loc: (72,4)-(72,5) = "{" │ │ ├── elements: (length: 2) - │ │ │ ├── @ AssocNode (location: (74,6)-(74,13)) + │ │ │ ├── @ AssocNode (location: (72,6)-(72,13)) │ │ │ │ ├── key: - │ │ │ │ │ @ SymbolNode (location: (74,6)-(74,8)) + │ │ │ │ │ @ SymbolNode (location: (72,6)-(72,8)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── opening_loc: ∅ - │ │ │ │ │ ├── value_loc: (74,6)-(74,7) = "a" - │ │ │ │ │ ├── closing_loc: (74,7)-(74,8) = ":" + │ │ │ │ │ ├── value_loc: (72,6)-(72,7) = "a" + │ │ │ │ │ ├── closing_loc: (72,7)-(72,8) = ":" │ │ │ │ │ └── unescaped: "a" │ │ │ │ ├── value: - │ │ │ │ │ @ TrueNode (location: (74,9)-(74,13)) + │ │ │ │ │ @ TrueNode (location: (72,9)-(72,13)) │ │ │ │ └── operator_loc: ∅ - │ │ │ └── @ AssocNode (location: (74,15)-(74,23)) + │ │ │ └── @ AssocNode (location: (72,15)-(72,23)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (74,15)-(74,17)) + │ │ │ │ @ SymbolNode (location: (72,15)-(72,17)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: ∅ - │ │ │ │ ├── value_loc: (74,15)-(74,16) = "b" - │ │ │ │ ├── closing_loc: (74,16)-(74,17) = ":" + │ │ │ │ ├── value_loc: (72,15)-(72,16) = "b" + │ │ │ │ ├── closing_loc: (72,16)-(72,17) = ":" │ │ │ │ └── unescaped: "b" │ │ │ ├── value: - │ │ │ │ @ FalseNode (location: (74,18)-(74,23)) + │ │ │ │ @ FalseNode (location: (72,18)-(72,23)) │ │ │ └── operator_loc: ∅ - │ │ └── closing_loc: (74,25)-(74,26) = "}" - │ ├── closing_loc: (74,35)-(74,36) = ")" + │ │ └── closing_loc: (72,25)-(72,26) = "}" + │ ├── closing_loc: (72,35)-(72,36) = ")" │ └── block: - │ @ BlockArgumentNode (location: (74,28)-(74,35)) + │ @ BlockArgumentNode (location: (72,28)-(72,35)) │ ├── expression: - │ │ @ SymbolNode (location: (74,29)-(74,35)) + │ │ @ SymbolNode (location: (72,29)-(72,35)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (74,29)-(74,30) = ":" - │ │ ├── value_loc: (74,30)-(74,35) = "block" + │ │ ├── opening_loc: (72,29)-(72,30) = ":" + │ │ ├── value_loc: (72,30)-(72,35) = "block" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "block" - │ └── operator_loc: (74,28)-(74,29) = "&" - ├── @ CallNode (location: (76,0)-(76,20)) + │ └── operator_loc: (72,28)-(72,29) = "&" + ├── @ CallNode (location: (74,0)-(74,20)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :hi - │ ├── message_loc: (76,0)-(76,2) = "hi" + │ ├── message_loc: (74,0)-(74,2) = "hi" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (76,3)-(76,20)) + │ │ @ ArgumentsNode (location: (74,3)-(74,20)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (76,3)-(76,20)) + │ │ └── @ KeywordHashNode (location: (74,3)-(74,20)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (76,3)-(76,20)) + │ │ └── @ AssocNode (location: (74,3)-(74,20)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (76,3)-(76,9)) + │ │ │ @ SymbolNode (location: (74,3)-(74,9)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (76,3)-(76,4) = ":" - │ │ │ ├── value_loc: (76,4)-(76,9) = "there" + │ │ │ ├── opening_loc: (74,3)-(74,4) = ":" + │ │ │ ├── value_loc: (74,4)-(74,9) = "there" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "there" │ │ ├── value: - │ │ │ @ SymbolNode (location: (76,13)-(76,20)) + │ │ │ @ SymbolNode (location: (74,13)-(74,20)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (76,13)-(76,14) = ":" - │ │ │ ├── value_loc: (76,14)-(76,20) = "friend" + │ │ │ ├── opening_loc: (74,13)-(74,14) = ":" + │ │ │ ├── value_loc: (74,14)-(74,20) = "friend" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "friend" - │ │ └── operator_loc: (76,10)-(76,12) = "=>" + │ │ └── operator_loc: (74,10)-(74,12) = "=>" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (78,0)-(80,1)) + ├── @ CallNode (location: (76,0)-(78,1)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (78,0)-(78,3) = "foo" - │ ├── opening_loc: (78,3)-(78,4) = "(" + │ ├── message_loc: (76,0)-(76,3) = "foo" + │ ├── opening_loc: (76,3)-(76,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (78,4)-(79,2)) + │ │ @ ArgumentsNode (location: (76,4)-(77,2)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (78,4)-(78,6)) + │ │ ├── @ SymbolNode (location: (76,4)-(76,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (78,4)-(78,5) = ":" - │ │ │ ├── value_loc: (78,5)-(78,6) = "a" + │ │ │ ├── opening_loc: (76,4)-(76,5) = ":" + │ │ │ ├── value_loc: (76,5)-(76,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ SymbolNode (location: (79,0)-(79,2)) + │ │ └── @ SymbolNode (location: (77,0)-(77,2)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (79,0)-(79,1) = ":" - │ │ ├── value_loc: (79,1)-(79,2) = "b" + │ │ ├── opening_loc: (77,0)-(77,1) = ":" + │ │ ├── value_loc: (77,1)-(77,2) = "b" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "b" - │ ├── closing_loc: (80,0)-(80,1) = ")" + │ ├── closing_loc: (78,0)-(78,1) = ")" │ └── block: ∅ - ├── @ CallNode (location: (82,0)-(85,1)) + ├── @ CallNode (location: (80,0)-(83,1)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (82,0)-(82,3) = "foo" - │ ├── opening_loc: (82,3)-(82,4) = "(" + │ ├── message_loc: (80,0)-(80,3) = "foo" + │ ├── opening_loc: (80,3)-(80,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (83,0)-(84,5)) + │ │ @ ArgumentsNode (location: (81,0)-(82,5)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (83,0)-(83,2)) + │ │ ├── @ SymbolNode (location: (81,0)-(81,2)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (83,0)-(83,1) = ":" - │ │ │ ├── value_loc: (83,1)-(83,2) = "a" + │ │ │ ├── opening_loc: (81,0)-(81,1) = ":" + │ │ │ ├── value_loc: (81,1)-(81,2) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ KeywordHashNode (location: (84,0)-(84,5)) + │ │ └── @ KeywordHashNode (location: (82,0)-(82,5)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (84,0)-(84,5)) + │ │ └── @ AssocNode (location: (82,0)-(82,5)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (84,0)-(84,2)) + │ │ │ @ SymbolNode (location: (82,0)-(82,2)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (84,0)-(84,1) = "b" - │ │ │ ├── closing_loc: (84,1)-(84,2) = ":" + │ │ │ ├── value_loc: (82,0)-(82,1) = "b" + │ │ │ ├── closing_loc: (82,1)-(82,2) = ":" │ │ │ └── unescaped: "b" │ │ ├── value: - │ │ │ @ SymbolNode (location: (84,3)-(84,5)) + │ │ │ @ SymbolNode (location: (82,3)-(82,5)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (84,3)-(84,4) = ":" - │ │ │ ├── value_loc: (84,4)-(84,5) = "c" + │ │ │ ├── opening_loc: (82,3)-(82,4) = ":" + │ │ │ ├── value_loc: (82,4)-(82,5) = "c" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "c" │ │ └── operator_loc: ∅ - │ ├── closing_loc: (85,0)-(85,1) = ")" + │ ├── closing_loc: (83,0)-(83,1) = ")" │ └── block: ∅ - ├── @ CallNode (location: (87,0)-(87,11)) + ├── @ CallNode (location: (85,0)-(85,11)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (87,0)-(87,3) = "foo" + │ ├── message_loc: (85,0)-(85,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: - │ @ BlockArgumentNode (location: (87,4)-(87,11)) + │ @ BlockArgumentNode (location: (85,4)-(85,11)) │ ├── expression: - │ │ @ SymbolNode (location: (87,5)-(87,11)) + │ │ @ SymbolNode (location: (85,5)-(85,11)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (87,5)-(87,6) = ":" - │ │ ├── value_loc: (87,6)-(87,11) = "block" + │ │ ├── opening_loc: (85,5)-(85,6) = ":" + │ │ ├── value_loc: (85,6)-(85,11) = "block" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "block" - │ └── operator_loc: (87,4)-(87,5) = "&" - ├── @ CallNode (location: (89,0)-(89,30)) + │ └── operator_loc: (85,4)-(85,5) = "&" + ├── @ CallNode (location: (87,0)-(87,30)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (89,0)-(89,3) = "foo" + │ ├── message_loc: (87,0)-(87,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (89,4)-(89,21)) + │ │ @ ArgumentsNode (location: (87,4)-(87,21)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (89,4)-(89,21)) + │ │ └── @ KeywordHashNode (location: (87,4)-(87,21)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 2) - │ │ ├── @ AssocNode (location: (89,4)-(89,11)) + │ │ ├── @ AssocNode (location: (87,4)-(87,11)) │ │ │ ├── key: - │ │ │ │ @ SymbolNode (location: (89,4)-(89,6)) + │ │ │ │ @ SymbolNode (location: (87,4)-(87,6)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── opening_loc: ∅ - │ │ │ │ ├── value_loc: (89,4)-(89,5) = "a" - │ │ │ │ ├── closing_loc: (89,5)-(89,6) = ":" + │ │ │ │ ├── value_loc: (87,4)-(87,5) = "a" + │ │ │ │ ├── closing_loc: (87,5)-(87,6) = ":" │ │ │ │ └── unescaped: "a" │ │ │ ├── value: - │ │ │ │ @ TrueNode (location: (89,7)-(89,11)) + │ │ │ │ @ TrueNode (location: (87,7)-(87,11)) │ │ │ └── operator_loc: ∅ - │ │ └── @ AssocNode (location: (89,13)-(89,21)) + │ │ └── @ AssocNode (location: (87,13)-(87,21)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (89,13)-(89,15)) + │ │ │ @ SymbolNode (location: (87,13)-(87,15)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (89,13)-(89,14) = "b" - │ │ │ ├── closing_loc: (89,14)-(89,15) = ":" + │ │ │ ├── value_loc: (87,13)-(87,14) = "b" + │ │ │ ├── closing_loc: (87,14)-(87,15) = ":" │ │ │ └── unescaped: "b" │ │ ├── value: - │ │ │ @ FalseNode (location: (89,16)-(89,21)) + │ │ │ @ FalseNode (location: (87,16)-(87,21)) │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: - │ @ BlockArgumentNode (location: (89,23)-(89,30)) + │ @ BlockArgumentNode (location: (87,23)-(87,30)) │ ├── expression: - │ │ @ SymbolNode (location: (89,24)-(89,30)) + │ │ @ SymbolNode (location: (87,24)-(87,30)) │ │ ├── flags: ∅ - │ │ ├── opening_loc: (89,24)-(89,25) = ":" - │ │ ├── value_loc: (89,25)-(89,30) = "block" + │ │ ├── opening_loc: (87,24)-(87,25) = ":" + │ │ ├── value_loc: (87,25)-(87,30) = "block" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "block" - │ └── operator_loc: (89,23)-(89,24) = "&" - ├── @ CallNode (location: (91,0)-(91,21)) + │ └── operator_loc: (87,23)-(87,24) = "&" + ├── @ CallNode (location: (89,0)-(89,21)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :some_func - │ ├── message_loc: (91,0)-(91,9) = "some_func" + │ ├── message_loc: (89,0)-(89,9) = "some_func" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (91,10)-(91,21)) + │ │ @ ArgumentsNode (location: (89,10)-(89,21)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ IntegerNode (location: (91,10)-(91,11)) + │ │ ├── @ IntegerNode (location: (89,10)-(89,11)) │ │ │ └── flags: decimal - │ │ └── @ KeywordHashNode (location: (91,13)-(91,21)) + │ │ └── @ KeywordHashNode (location: (89,13)-(89,21)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (91,13)-(91,21)) + │ │ └── @ AssocNode (location: (89,13)-(89,21)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (91,13)-(91,19)) + │ │ │ @ SymbolNode (location: (89,13)-(89,19)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (91,13)-(91,18) = "kwarg" - │ │ │ ├── closing_loc: (91,18)-(91,19) = ":" + │ │ │ ├── value_loc: (89,13)-(89,18) = "kwarg" + │ │ │ ├── closing_loc: (89,18)-(89,19) = ":" │ │ │ └── unescaped: "kwarg" │ │ ├── value: - │ │ │ @ IntegerNode (location: (91,20)-(91,21)) + │ │ │ @ IntegerNode (location: (89,20)-(89,21)) │ │ │ └── flags: decimal │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (93,0)-(93,18)) + ├── @ CallNode (location: (91,0)-(91,18)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ ConstantReadNode (location: (93,0)-(93,6)) + │ │ @ ConstantReadNode (location: (91,0)-(91,6)) │ │ └── name: :Kernel - │ ├── call_operator_loc: (93,6)-(93,7) = "." + │ ├── call_operator_loc: (91,6)-(91,7) = "." │ ├── name: :Integer - │ ├── message_loc: (93,7)-(93,14) = "Integer" - │ ├── opening_loc: (93,14)-(93,15) = "(" + │ ├── message_loc: (91,7)-(91,14) = "Integer" + │ ├── opening_loc: (91,14)-(91,15) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (93,15)-(93,17)) + │ │ @ ArgumentsNode (location: (91,15)-(91,17)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ IntegerNode (location: (93,15)-(93,17)) + │ │ └── @ IntegerNode (location: (91,15)-(91,17)) │ │ └── flags: decimal - │ ├── closing_loc: (93,17)-(93,18) = ")" + │ ├── closing_loc: (91,17)-(91,18) = ")" │ └── block: ∅ - ├── @ CallNode (location: (95,0)-(95,10)) + ├── @ CallNode (location: (93,0)-(93,10)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (95,0)-(95,1)) + │ │ @ CallNode (location: (93,0)-(93,1)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :x - │ │ ├── message_loc: (95,0)-(95,1) = "x" + │ │ ├── message_loc: (93,0)-(93,1) = "x" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (95,1)-(95,2) = "." + │ ├── call_operator_loc: (93,1)-(93,2) = "." │ ├── name: :each - │ ├── message_loc: (95,2)-(95,6) = "each" + │ ├── message_loc: (93,2)-(93,6) = "each" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: - │ @ BlockNode (location: (95,7)-(95,10)) + │ @ BlockNode (location: (93,7)-(93,10)) │ ├── locals: [] │ ├── locals_body_index: 0 │ ├── parameters: ∅ │ ├── body: ∅ - │ ├── opening_loc: (95,7)-(95,8) = "{" - │ └── closing_loc: (95,9)-(95,10) = "}" - ├── @ CallNode (location: (97,0)-(97,14)) + │ ├── opening_loc: (93,7)-(93,8) = "{" + │ └── closing_loc: (93,9)-(93,10) = "}" + ├── @ CallNode (location: (95,0)-(95,14)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (97,0)-(97,3)) + │ │ @ CallNode (location: (95,0)-(95,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :foo - │ │ ├── message_loc: (97,0)-(97,3) = "foo" + │ │ ├── message_loc: (95,0)-(95,3) = "foo" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ - │ ├── call_operator_loc: (97,3)-(97,4) = "." + │ ├── call_operator_loc: (95,3)-(95,4) = "." │ ├── name: :map - │ ├── message_loc: (97,4)-(97,7) = "map" + │ ├── message_loc: (95,4)-(95,7) = "map" │ ├── opening_loc: ∅ │ ├── arguments: ∅ │ ├── closing_loc: ∅ │ └── block: - │ @ BlockNode (location: (97,8)-(97,14)) + │ @ BlockNode (location: (95,8)-(95,14)) │ ├── locals: [] │ ├── locals_body_index: 0 │ ├── parameters: ∅ │ ├── body: - │ │ @ StatementsNode (location: (97,10)-(97,12)) + │ │ @ StatementsNode (location: (95,10)-(95,12)) │ │ └── body: (length: 1) - │ │ └── @ BackReferenceReadNode (location: (97,10)-(97,12)) + │ │ └── @ BackReferenceReadNode (location: (95,10)-(95,12)) │ │ └── name: :$& - │ ├── opening_loc: (97,8)-(97,9) = "{" - │ └── closing_loc: (97,13)-(97,14) = "}" - ├── @ CallNode (location: (99,0)-(99,12)) + │ ├── opening_loc: (95,8)-(95,9) = "{" + │ └── closing_loc: (95,13)-(95,14) = "}" + ├── @ CallNode (location: (97,0)-(97,12)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantPathNode (location: (97,0)-(97,4)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (97,0)-(97,1)) + │ │ │ └── name: :A + │ │ ├── child: + │ │ │ @ ConstantReadNode (location: (97,3)-(97,4)) + │ │ │ └── name: :B + │ │ └── delimiter_loc: (97,1)-(97,3) = "::" + │ ├── call_operator_loc: (97,4)-(97,6) = "::" + │ ├── name: :C + │ ├── message_loc: (97,6)-(97,7) = "C" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (97,8)-(97,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (97,8)-(97,12)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (97,8)-(97,9) = ":" + │ │ ├── value_loc: (97,9)-(97,12) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (99,0)-(99,13)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ConstantPathNode (location: (99,0)-(99,4)) @@ -1468,7 +1470,7 @@ │ ├── call_operator_loc: (99,4)-(99,6) = "::" │ ├── name: :C │ ├── message_loc: (99,6)-(99,7) = "C" - │ ├── opening_loc: ∅ + │ ├── opening_loc: (99,7)-(99,8) = "(" │ ├── arguments: │ │ @ ArgumentsNode (location: (99,8)-(99,12)) │ │ ├── flags: ∅ @@ -1479,9 +1481,9 @@ │ │ ├── value_loc: (99,9)-(99,12) = "foo" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "foo" - │ ├── closing_loc: ∅ + │ ├── closing_loc: (99,12)-(99,13) = ")" │ └── block: ∅ - ├── @ CallNode (location: (101,0)-(101,13)) + ├── @ CallNode (location: (101,0)-(101,17)) │ ├── flags: ∅ │ ├── receiver: │ │ @ ConstantPathNode (location: (101,0)-(101,4)) @@ -1507,458 +1509,431 @@ │ │ ├── closing_loc: ∅ │ │ └── unescaped: "foo" │ ├── closing_loc: (101,12)-(101,13) = ")" - │ └── block: ∅ - ├── @ CallNode (location: (103,0)-(103,17)) - │ ├── flags: ∅ - │ ├── receiver: - │ │ @ ConstantPathNode (location: (103,0)-(103,4)) - │ │ ├── parent: - │ │ │ @ ConstantReadNode (location: (103,0)-(103,1)) - │ │ │ └── name: :A - │ │ ├── child: - │ │ │ @ ConstantReadNode (location: (103,3)-(103,4)) - │ │ │ └── name: :B - │ │ └── delimiter_loc: (103,1)-(103,3) = "::" - │ ├── call_operator_loc: (103,4)-(103,6) = "::" - │ ├── name: :C - │ ├── message_loc: (103,6)-(103,7) = "C" - │ ├── opening_loc: (103,7)-(103,8) = "(" - │ ├── arguments: - │ │ @ ArgumentsNode (location: (103,8)-(103,12)) - │ │ ├── flags: ∅ - │ │ └── arguments: (length: 1) - │ │ └── @ SymbolNode (location: (103,8)-(103,12)) - │ │ ├── flags: ∅ - │ │ ├── opening_loc: (103,8)-(103,9) = ":" - │ │ ├── value_loc: (103,9)-(103,12) = "foo" - │ │ ├── closing_loc: ∅ - │ │ └── unescaped: "foo" - │ ├── closing_loc: (103,12)-(103,13) = ")" │ └── block: - │ @ BlockNode (location: (103,14)-(103,17)) + │ @ BlockNode (location: (101,14)-(101,17)) │ ├── locals: [] │ ├── locals_body_index: 0 │ ├── parameters: ∅ │ ├── body: ∅ - │ ├── opening_loc: (103,14)-(103,15) = "{" - │ └── closing_loc: (103,16)-(103,17) = "}" - ├── @ CallNode (location: (105,0)-(105,12)) + │ ├── opening_loc: (101,14)-(101,15) = "{" + │ └── closing_loc: (101,16)-(101,17) = "}" + ├── @ CallNode (location: (103,0)-(103,12)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (105,0)-(105,3) = "foo" - │ ├── opening_loc: (105,3)-(105,4) = "(" + │ ├── message_loc: (103,0)-(103,3) = "foo" + │ ├── opening_loc: (103,3)-(103,4) = "(" │ ├── arguments: - │ │ @ ArgumentsNode (location: (105,4)-(105,11)) + │ │ @ ArgumentsNode (location: (103,4)-(103,11)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (105,4)-(105,11)) + │ │ └── @ KeywordHashNode (location: (103,4)-(103,11)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (105,4)-(105,11)) + │ │ └── @ AssocNode (location: (103,4)-(103,11)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (105,4)-(105,8)) + │ │ │ @ SymbolNode (location: (103,4)-(103,8)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (105,4)-(105,5) = "\"" - │ │ │ ├── value_loc: (105,5)-(105,6) = "a" - │ │ │ ├── closing_loc: (105,6)-(105,8) = "\":" + │ │ │ ├── opening_loc: (103,4)-(103,5) = "\"" + │ │ │ ├── value_loc: (103,5)-(103,6) = "a" + │ │ │ ├── closing_loc: (103,6)-(103,8) = "\":" │ │ │ └── unescaped: "a" │ │ ├── value: - │ │ │ @ IntegerNode (location: (105,9)-(105,11)) + │ │ │ @ IntegerNode (location: (103,9)-(103,11)) │ │ │ └── flags: decimal │ │ └── operator_loc: ∅ - │ ├── closing_loc: (105,11)-(105,12) = ")" + │ ├── closing_loc: (103,11)-(103,12) = ")" │ └── block: ∅ - ├── @ CallNode (location: (107,0)-(107,28)) + ├── @ CallNode (location: (105,0)-(105,28)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (107,0)-(107,3) = "foo" + │ ├── message_loc: (105,0)-(105,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (107,4)-(107,28)) + │ │ @ ArgumentsNode (location: (105,4)-(105,28)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (107,4)-(107,28)) + │ │ └── @ KeywordHashNode (location: (105,4)-(105,28)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (107,4)-(107,28)) + │ │ └── @ AssocNode (location: (105,4)-(105,28)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (107,4)-(107,8)) + │ │ │ @ SymbolNode (location: (105,4)-(105,8)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (107,4)-(107,7) = "bar" - │ │ │ ├── closing_loc: (107,7)-(107,8) = ":" + │ │ │ ├── value_loc: (105,4)-(105,7) = "bar" + │ │ │ ├── closing_loc: (105,7)-(105,8) = ":" │ │ │ └── unescaped: "bar" │ │ ├── value: - │ │ │ @ HashNode (location: (107,9)-(107,28)) - │ │ │ ├── opening_loc: (107,9)-(107,10) = "{" + │ │ │ @ HashNode (location: (105,9)-(105,28)) + │ │ │ ├── opening_loc: (105,9)-(105,10) = "{" │ │ │ ├── elements: (length: 1) - │ │ │ │ └── @ AssocNode (location: (107,11)-(107,26)) + │ │ │ │ └── @ AssocNode (location: (105,11)-(105,26)) │ │ │ │ ├── key: - │ │ │ │ │ @ SymbolNode (location: (107,11)-(107,15)) + │ │ │ │ │ @ SymbolNode (location: (105,11)-(105,15)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── opening_loc: ∅ - │ │ │ │ │ ├── value_loc: (107,11)-(107,14) = "baz" - │ │ │ │ │ ├── closing_loc: (107,14)-(107,15) = ":" + │ │ │ │ │ ├── value_loc: (105,11)-(105,14) = "baz" + │ │ │ │ │ ├── closing_loc: (105,14)-(105,15) = ":" │ │ │ │ │ └── unescaped: "baz" │ │ │ │ ├── value: - │ │ │ │ │ @ CallNode (location: (107,16)-(107,26)) + │ │ │ │ │ @ CallNode (location: (105,16)-(105,26)) │ │ │ │ │ ├── flags: ignore_visibility │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :qux - │ │ │ │ │ ├── message_loc: (107,16)-(107,19) = "qux" + │ │ │ │ │ ├── message_loc: (105,16)-(105,19) = "qux" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── block: - │ │ │ │ │ @ BlockNode (location: (107,20)-(107,26)) + │ │ │ │ │ @ BlockNode (location: (105,20)-(105,26)) │ │ │ │ │ ├── locals: [] │ │ │ │ │ ├── locals_body_index: 0 │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ ├── body: ∅ - │ │ │ │ │ ├── opening_loc: (107,20)-(107,22) = "do" - │ │ │ │ │ └── closing_loc: (107,23)-(107,26) = "end" + │ │ │ │ │ ├── opening_loc: (105,20)-(105,22) = "do" + │ │ │ │ │ └── closing_loc: (105,23)-(105,26) = "end" │ │ │ │ └── operator_loc: ∅ - │ │ │ └── closing_loc: (107,27)-(107,28) = "}" + │ │ │ └── closing_loc: (105,27)-(105,28) = "}" │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (109,0)-(109,24)) + ├── @ CallNode (location: (107,0)-(107,24)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (109,0)-(109,3) = "foo" + │ ├── message_loc: (107,0)-(107,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (109,4)-(109,24)) + │ │ @ ArgumentsNode (location: (107,4)-(107,24)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ KeywordHashNode (location: (109,4)-(109,24)) + │ │ └── @ KeywordHashNode (location: (107,4)-(107,24)) │ │ ├── flags: symbol_keys │ │ └── elements: (length: 1) - │ │ └── @ AssocNode (location: (109,4)-(109,24)) + │ │ └── @ AssocNode (location: (107,4)-(107,24)) │ │ ├── key: - │ │ │ @ SymbolNode (location: (109,4)-(109,8)) + │ │ │ @ SymbolNode (location: (107,4)-(107,8)) │ │ │ ├── flags: ∅ │ │ │ ├── opening_loc: ∅ - │ │ │ ├── value_loc: (109,4)-(109,7) = "bar" - │ │ │ ├── closing_loc: (109,7)-(109,8) = ":" + │ │ │ ├── value_loc: (107,4)-(107,7) = "bar" + │ │ │ ├── closing_loc: (107,7)-(107,8) = ":" │ │ │ └── unescaped: "bar" │ │ ├── value: - │ │ │ @ HashNode (location: (109,9)-(109,24)) - │ │ │ ├── opening_loc: (109,9)-(109,10) = "{" + │ │ │ @ HashNode (location: (107,9)-(107,24)) + │ │ │ ├── opening_loc: (107,9)-(107,10) = "{" │ │ │ ├── elements: (length: 1) - │ │ │ │ └── @ AssocSplatNode (location: (109,11)-(109,22)) + │ │ │ │ └── @ AssocSplatNode (location: (107,11)-(107,22)) │ │ │ │ ├── value: - │ │ │ │ │ @ CallNode (location: (109,13)-(109,22)) + │ │ │ │ │ @ CallNode (location: (107,13)-(107,22)) │ │ │ │ │ ├── flags: ignore_visibility │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :kw - │ │ │ │ │ ├── message_loc: (109,13)-(109,15) = "kw" + │ │ │ │ │ ├── message_loc: (107,13)-(107,15) = "kw" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── block: - │ │ │ │ │ @ BlockNode (location: (109,16)-(109,22)) + │ │ │ │ │ @ BlockNode (location: (107,16)-(107,22)) │ │ │ │ │ ├── locals: [] │ │ │ │ │ ├── locals_body_index: 0 │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ ├── body: ∅ - │ │ │ │ │ ├── opening_loc: (109,16)-(109,18) = "do" - │ │ │ │ │ └── closing_loc: (109,19)-(109,22) = "end" - │ │ │ │ └── operator_loc: (109,11)-(109,13) = "**" - │ │ │ └── closing_loc: (109,23)-(109,24) = "}" + │ │ │ │ │ ├── opening_loc: (107,16)-(107,18) = "do" + │ │ │ │ │ └── closing_loc: (107,19)-(107,22) = "end" + │ │ │ │ └── operator_loc: (107,11)-(107,13) = "**" + │ │ │ └── closing_loc: (107,23)-(107,24) = "}" │ │ └── operator_loc: ∅ │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (111,0)-(111,36)) + ├── @ CallNode (location: (109,0)-(109,36)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (111,0)-(111,3) = "foo" + │ ├── message_loc: (109,0)-(109,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (111,4)-(111,29)) + │ │ @ ArgumentsNode (location: (109,4)-(109,29)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ InterpolatedStringNode (location: (111,4)-(111,29)) - │ │ ├── opening_loc: (111,4)-(111,5) = "\"" + │ │ └── @ InterpolatedStringNode (location: (109,4)-(109,29)) + │ │ ├── opening_loc: (109,4)-(109,5) = "\"" │ │ ├── parts: (length: 1) - │ │ │ └── @ EmbeddedStatementsNode (location: (111,5)-(111,28)) - │ │ │ ├── opening_loc: (111,5)-(111,7) = "\#{" + │ │ │ └── @ EmbeddedStatementsNode (location: (109,5)-(109,28)) + │ │ │ ├── opening_loc: (109,5)-(109,7) = "\#{" │ │ │ ├── statements: - │ │ │ │ @ StatementsNode (location: (111,7)-(111,27)) + │ │ │ │ @ StatementsNode (location: (109,7)-(109,27)) │ │ │ │ └── body: (length: 1) - │ │ │ │ └── @ CallNode (location: (111,7)-(111,27)) + │ │ │ │ └── @ CallNode (location: (109,7)-(109,27)) │ │ │ │ ├── flags: ∅ │ │ │ │ ├── receiver: - │ │ │ │ │ @ CallNode (location: (111,7)-(111,10)) + │ │ │ │ │ @ CallNode (location: (109,7)-(109,10)) │ │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── name: :bar - │ │ │ │ │ ├── message_loc: (111,7)-(111,10) = "bar" + │ │ │ │ │ ├── message_loc: (109,7)-(109,10) = "bar" │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ └── block: ∅ - │ │ │ │ ├── call_operator_loc: (111,10)-(111,11) = "." + │ │ │ │ ├── call_operator_loc: (109,10)-(109,11) = "." │ │ │ │ ├── name: :map - │ │ │ │ ├── message_loc: (111,11)-(111,14) = "map" + │ │ │ │ ├── message_loc: (109,11)-(109,14) = "map" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: - │ │ │ │ @ BlockNode (location: (111,15)-(111,27)) + │ │ │ │ @ BlockNode (location: (109,15)-(109,27)) │ │ │ │ ├── locals: [] │ │ │ │ ├── locals_body_index: 0 │ │ │ │ ├── parameters: ∅ │ │ │ │ ├── body: - │ │ │ │ │ @ StatementsNode (location: (111,18)-(111,23)) + │ │ │ │ │ @ StatementsNode (location: (109,18)-(109,23)) │ │ │ │ │ └── body: (length: 1) - │ │ │ │ │ └── @ StringNode (location: (111,18)-(111,23)) + │ │ │ │ │ └── @ StringNode (location: (109,18)-(109,23)) │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ ├── opening_loc: (111,18)-(111,19) = "\"" - │ │ │ │ │ ├── content_loc: (111,19)-(111,22) = "baz" - │ │ │ │ │ ├── closing_loc: (111,22)-(111,23) = "\"" + │ │ │ │ │ ├── opening_loc: (109,18)-(109,19) = "\"" + │ │ │ │ │ ├── content_loc: (109,19)-(109,22) = "baz" + │ │ │ │ │ ├── closing_loc: (109,22)-(109,23) = "\"" │ │ │ │ │ └── unescaped: "baz" - │ │ │ │ ├── opening_loc: (111,15)-(111,17) = "do" - │ │ │ │ └── closing_loc: (111,24)-(111,27) = "end" - │ │ │ └── closing_loc: (111,27)-(111,28) = "}" - │ │ └── closing_loc: (111,28)-(111,29) = "\"" + │ │ │ │ ├── opening_loc: (109,15)-(109,17) = "do" + │ │ │ │ └── closing_loc: (109,24)-(109,27) = "end" + │ │ │ └── closing_loc: (109,27)-(109,28) = "}" + │ │ └── closing_loc: (109,28)-(109,29) = "\"" │ ├── closing_loc: ∅ │ └── block: - │ @ BlockNode (location: (111,30)-(111,36)) + │ @ BlockNode (location: (109,30)-(109,36)) │ ├── locals: [] │ ├── locals_body_index: 0 │ ├── parameters: ∅ │ ├── body: ∅ - │ ├── opening_loc: (111,30)-(111,32) = "do" - │ └── closing_loc: (111,33)-(111,36) = "end" - ├── @ CallNode (location: (113,0)-(113,28)) + │ ├── opening_loc: (109,30)-(109,32) = "do" + │ └── closing_loc: (109,33)-(109,36) = "end" + ├── @ CallNode (location: (111,0)-(111,28)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (113,0)-(113,3) = "foo" + │ ├── message_loc: (111,0)-(111,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (113,4)-(113,28)) + │ │ @ ArgumentsNode (location: (111,4)-(111,28)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ ClassNode (location: (113,4)-(113,28)) + │ │ └── @ ClassNode (location: (111,4)-(111,28)) │ │ ├── locals: [] - │ │ ├── class_keyword_loc: (113,4)-(113,9) = "class" + │ │ ├── class_keyword_loc: (111,4)-(111,9) = "class" │ │ ├── constant_path: - │ │ │ @ ConstantReadNode (location: (113,10)-(113,13)) + │ │ │ @ ConstantReadNode (location: (111,10)-(111,13)) │ │ │ └── name: :Bar │ │ ├── inheritance_operator_loc: ∅ │ │ ├── superclass: ∅ │ │ ├── body: - │ │ │ @ StatementsNode (location: (113,14)-(113,24)) + │ │ │ @ StatementsNode (location: (111,14)-(111,24)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (113,14)-(113,24)) + │ │ │ └── @ CallNode (location: (111,14)-(111,24)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz - │ │ │ ├── message_loc: (113,14)-(113,17) = "baz" + │ │ │ ├── message_loc: (111,14)-(111,17) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (113,18)-(113,24)) + │ │ │ @ BlockNode (location: (111,18)-(111,24)) │ │ │ ├── locals: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── parameters: ∅ │ │ │ ├── body: ∅ - │ │ │ ├── opening_loc: (113,18)-(113,20) = "do" - │ │ │ └── closing_loc: (113,21)-(113,24) = "end" - │ │ ├── end_keyword_loc: (113,25)-(113,28) = "end" + │ │ │ ├── opening_loc: (111,18)-(111,20) = "do" + │ │ │ └── closing_loc: (111,21)-(111,24) = "end" + │ │ ├── end_keyword_loc: (111,25)-(111,28) = "end" │ │ └── name: :Bar │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (115,0)-(115,29)) + ├── @ CallNode (location: (113,0)-(113,29)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (115,0)-(115,3) = "foo" + │ ├── message_loc: (113,0)-(113,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (115,4)-(115,29)) + │ │ @ ArgumentsNode (location: (113,4)-(113,29)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ ModuleNode (location: (115,4)-(115,29)) + │ │ └── @ ModuleNode (location: (113,4)-(113,29)) │ │ ├── locals: [] - │ │ ├── module_keyword_loc: (115,4)-(115,10) = "module" + │ │ ├── module_keyword_loc: (113,4)-(113,10) = "module" │ │ ├── constant_path: - │ │ │ @ ConstantReadNode (location: (115,11)-(115,14)) + │ │ │ @ ConstantReadNode (location: (113,11)-(113,14)) │ │ │ └── name: :Bar │ │ ├── body: - │ │ │ @ StatementsNode (location: (115,15)-(115,25)) + │ │ │ @ StatementsNode (location: (113,15)-(113,25)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (115,15)-(115,25)) + │ │ │ └── @ CallNode (location: (113,15)-(113,25)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz - │ │ │ ├── message_loc: (115,15)-(115,18) = "baz" + │ │ │ ├── message_loc: (113,15)-(113,18) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (115,19)-(115,25)) + │ │ │ @ BlockNode (location: (113,19)-(113,25)) │ │ │ ├── locals: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── parameters: ∅ │ │ │ ├── body: ∅ - │ │ │ ├── opening_loc: (115,19)-(115,21) = "do" - │ │ │ └── closing_loc: (115,22)-(115,25) = "end" - │ │ ├── end_keyword_loc: (115,26)-(115,29) = "end" + │ │ │ ├── opening_loc: (113,19)-(113,21) = "do" + │ │ │ └── closing_loc: (113,22)-(113,25) = "end" + │ │ ├── end_keyword_loc: (113,26)-(113,29) = "end" │ │ └── name: :Bar │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (117,0)-(117,16)) + ├── @ CallNode (location: (115,0)-(115,16)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (117,0)-(117,3) = "foo" + │ ├── message_loc: (115,0)-(115,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (117,4)-(117,16)) + │ │ @ ArgumentsNode (location: (115,4)-(115,16)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ ArrayNode (location: (117,4)-(117,16)) + │ │ └── @ ArrayNode (location: (115,4)-(115,16)) │ │ ├── flags: ∅ │ │ ├── elements: (length: 1) - │ │ │ └── @ CallNode (location: (117,5)-(117,15)) + │ │ │ └── @ CallNode (location: (115,5)-(115,15)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :baz - │ │ │ ├── message_loc: (117,5)-(117,8) = "baz" + │ │ │ ├── message_loc: (115,5)-(115,8) = "baz" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (117,9)-(117,15)) + │ │ │ @ BlockNode (location: (115,9)-(115,15)) │ │ │ ├── locals: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── parameters: ∅ │ │ │ ├── body: ∅ - │ │ │ ├── opening_loc: (117,9)-(117,11) = "do" - │ │ │ └── closing_loc: (117,12)-(117,15) = "end" - │ │ ├── opening_loc: (117,4)-(117,5) = "[" - │ │ └── closing_loc: (117,15)-(117,16) = "]" + │ │ │ ├── opening_loc: (115,9)-(115,11) = "do" + │ │ │ └── closing_loc: (115,12)-(115,15) = "end" + │ │ ├── opening_loc: (115,4)-(115,5) = "[" + │ │ └── closing_loc: (115,15)-(115,16) = "]" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (119,0)-(119,28)) + ├── @ CallNode (location: (117,0)-(117,28)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :p - │ ├── message_loc: (119,0)-(119,1) = "p" + │ ├── message_loc: (117,0)-(117,1) = "p" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (119,2)-(119,28)) + │ │ @ ArgumentsNode (location: (117,2)-(117,28)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ BeginNode (location: (119,2)-(119,28)) - │ │ ├── begin_keyword_loc: (119,2)-(119,7) = "begin" + │ │ └── @ BeginNode (location: (117,2)-(117,28)) + │ │ ├── begin_keyword_loc: (117,2)-(117,7) = "begin" │ │ ├── statements: - │ │ │ @ StatementsNode (location: (119,8)-(119,24)) + │ │ │ @ StatementsNode (location: (117,8)-(117,24)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (119,8)-(119,24)) + │ │ │ └── @ CallNode (location: (117,8)-(117,24)) │ │ │ ├── flags: ∅ │ │ │ ├── receiver: - │ │ │ │ @ IntegerNode (location: (119,8)-(119,9)) + │ │ │ │ @ IntegerNode (location: (117,8)-(117,9)) │ │ │ │ └── flags: decimal - │ │ │ ├── call_operator_loc: (119,9)-(119,10) = "." + │ │ │ ├── call_operator_loc: (117,9)-(117,10) = "." │ │ │ ├── name: :times - │ │ │ ├── message_loc: (119,10)-(119,15) = "times" + │ │ │ ├── message_loc: (117,10)-(117,15) = "times" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (119,16)-(119,24)) + │ │ │ @ BlockNode (location: (117,16)-(117,24)) │ │ │ ├── locals: [] │ │ │ ├── locals_body_index: 0 │ │ │ ├── parameters: ∅ │ │ │ ├── body: - │ │ │ │ @ StatementsNode (location: (119,19)-(119,20)) + │ │ │ │ @ StatementsNode (location: (117,19)-(117,20)) │ │ │ │ └── body: (length: 1) - │ │ │ │ └── @ IntegerNode (location: (119,19)-(119,20)) + │ │ │ │ └── @ IntegerNode (location: (117,19)-(117,20)) │ │ │ │ └── flags: decimal - │ │ │ ├── opening_loc: (119,16)-(119,18) = "do" - │ │ │ └── closing_loc: (119,21)-(119,24) = "end" + │ │ │ ├── opening_loc: (117,16)-(117,18) = "do" + │ │ │ └── closing_loc: (117,21)-(117,24) = "end" │ │ ├── rescue_clause: ∅ │ │ ├── else_clause: ∅ │ │ ├── ensure_clause: ∅ - │ │ └── end_keyword_loc: (119,25)-(119,28) = "end" + │ │ └── end_keyword_loc: (117,25)-(117,28) = "end" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (121,0)-(126,5)) + ├── @ CallNode (location: (119,0)-(124,5)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (121,0)-(121,3) = "foo" + │ ├── message_loc: (119,0)-(119,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (121,4)-(126,5)) + │ │ @ ArgumentsNode (location: (119,4)-(124,5)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ SymbolNode (location: (121,4)-(121,6)) + │ │ ├── @ SymbolNode (location: (119,4)-(119,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (121,4)-(121,5) = ":" - │ │ │ ├── value_loc: (121,5)-(121,6) = "a" + │ │ │ ├── opening_loc: (119,4)-(119,5) = ":" + │ │ │ ├── value_loc: (119,5)-(119,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ └── @ IfNode (location: (122,2)-(126,5)) - │ │ ├── if_keyword_loc: (122,2)-(122,4) = "if" + │ │ └── @ IfNode (location: (120,2)-(124,5)) + │ │ ├── if_keyword_loc: (120,2)-(120,4) = "if" │ │ ├── predicate: - │ │ │ @ CallNode (location: (122,5)-(122,6)) + │ │ │ @ CallNode (location: (120,5)-(120,6)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :x - │ │ │ ├── message_loc: (122,5)-(122,6) = "x" + │ │ │ ├── message_loc: (120,5)-(120,6) = "x" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ ├── then_keyword_loc: ∅ │ │ ├── statements: - │ │ │ @ StatementsNode (location: (123,4)-(125,7)) + │ │ │ @ StatementsNode (location: (121,4)-(123,7)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (123,4)-(125,7)) + │ │ │ └── @ CallNode (location: (121,4)-(123,7)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar - │ │ │ ├── message_loc: (123,4)-(123,7) = "bar" + │ │ │ ├── message_loc: (121,4)-(121,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (123,8)-(125,7)) + │ │ │ @ BlockNode (location: (121,8)-(123,7)) │ │ │ ├── locals: [:a] │ │ │ ├── locals_body_index: 1 │ │ │ ├── parameters: - │ │ │ │ @ BlockParametersNode (location: (123,11)-(123,14)) + │ │ │ │ @ BlockParametersNode (location: (121,11)-(121,14)) │ │ │ │ ├── parameters: - │ │ │ │ │ @ ParametersNode (location: (123,12)-(123,13)) + │ │ │ │ │ @ ParametersNode (location: (121,12)-(121,13)) │ │ │ │ │ ├── requireds: (length: 1) - │ │ │ │ │ │ └── @ RequiredParameterNode (location: (123,12)-(123,13)) + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (121,12)-(121,13)) │ │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ │ └── name: :a │ │ │ │ │ ├── optionals: (length: 0) @@ -1968,74 +1943,74 @@ │ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ │ └── block: ∅ │ │ │ │ ├── locals: (length: 0) - │ │ │ │ ├── opening_loc: (123,11)-(123,12) = "|" - │ │ │ │ └── closing_loc: (123,13)-(123,14) = "|" + │ │ │ │ ├── opening_loc: (121,11)-(121,12) = "|" + │ │ │ │ └── closing_loc: (121,13)-(121,14) = "|" │ │ │ ├── body: - │ │ │ │ @ StatementsNode (location: (124,6)-(124,7)) + │ │ │ │ @ StatementsNode (location: (122,6)-(122,7)) │ │ │ │ └── body: (length: 1) - │ │ │ │ └── @ LocalVariableReadNode (location: (124,6)-(124,7)) + │ │ │ │ └── @ LocalVariableReadNode (location: (122,6)-(122,7)) │ │ │ │ ├── name: :a │ │ │ │ └── depth: 0 - │ │ │ ├── opening_loc: (123,8)-(123,10) = "do" - │ │ │ └── closing_loc: (125,4)-(125,7) = "end" + │ │ │ ├── opening_loc: (121,8)-(121,10) = "do" + │ │ │ └── closing_loc: (123,4)-(123,7) = "end" │ │ ├── consequent: ∅ - │ │ └── end_keyword_loc: (126,2)-(126,5) = "end" + │ │ └── end_keyword_loc: (124,2)-(124,5) = "end" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (128,0)-(137,5)) + ├── @ CallNode (location: (126,0)-(135,5)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (128,0)-(128,3) = "foo" + │ ├── message_loc: (126,0)-(126,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (128,4)-(137,5)) + │ │ @ ArgumentsNode (location: (126,4)-(135,5)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 3) - │ │ ├── @ SymbolNode (location: (128,4)-(128,6)) + │ │ ├── @ SymbolNode (location: (126,4)-(126,6)) │ │ │ ├── flags: ∅ - │ │ │ ├── opening_loc: (128,4)-(128,5) = ":" - │ │ │ ├── value_loc: (128,5)-(128,6) = "a" + │ │ │ ├── opening_loc: (126,4)-(126,5) = ":" + │ │ │ ├── value_loc: (126,5)-(126,6) = "a" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "a" - │ │ ├── @ WhileNode (location: (129,2)-(133,5)) + │ │ ├── @ WhileNode (location: (127,2)-(131,5)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (129,2)-(129,7) = "while" - │ │ │ ├── closing_loc: (133,2)-(133,5) = "end" + │ │ │ ├── keyword_loc: (127,2)-(127,7) = "while" + │ │ │ ├── closing_loc: (131,2)-(131,5) = "end" │ │ │ ├── predicate: - │ │ │ │ @ CallNode (location: (129,8)-(129,9)) + │ │ │ │ @ CallNode (location: (127,8)-(127,9)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :x - │ │ │ │ ├── message_loc: (129,8)-(129,9) = "x" + │ │ │ │ ├── message_loc: (127,8)-(127,9) = "x" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ │ │ │ └── statements: - │ │ │ @ StatementsNode (location: (130,4)-(132,7)) + │ │ │ @ StatementsNode (location: (128,4)-(130,7)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (130,4)-(132,7)) + │ │ │ └── @ CallNode (location: (128,4)-(130,7)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :bar - │ │ │ ├── message_loc: (130,4)-(130,7) = "bar" + │ │ │ ├── message_loc: (128,4)-(128,7) = "bar" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: - │ │ │ @ BlockNode (location: (130,8)-(132,7)) + │ │ │ @ BlockNode (location: (128,8)-(130,7)) │ │ │ ├── locals: [:a] │ │ │ ├── locals_body_index: 1 │ │ │ ├── parameters: - │ │ │ │ @ BlockParametersNode (location: (130,11)-(130,14)) + │ │ │ │ @ BlockParametersNode (location: (128,11)-(128,14)) │ │ │ │ ├── parameters: - │ │ │ │ │ @ ParametersNode (location: (130,12)-(130,13)) + │ │ │ │ │ @ ParametersNode (location: (128,12)-(128,13)) │ │ │ │ │ ├── requireds: (length: 1) - │ │ │ │ │ │ └── @ RequiredParameterNode (location: (130,12)-(130,13)) + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (128,12)-(128,13)) │ │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ │ └── name: :a │ │ │ │ │ ├── optionals: (length: 0) @@ -2045,121 +2020,121 @@ │ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ │ └── block: ∅ │ │ │ │ ├── locals: (length: 0) - │ │ │ │ ├── opening_loc: (130,11)-(130,12) = "|" - │ │ │ │ └── closing_loc: (130,13)-(130,14) = "|" + │ │ │ │ ├── opening_loc: (128,11)-(128,12) = "|" + │ │ │ │ └── closing_loc: (128,13)-(128,14) = "|" │ │ │ ├── body: - │ │ │ │ @ StatementsNode (location: (131,6)-(131,7)) + │ │ │ │ @ StatementsNode (location: (129,6)-(129,7)) │ │ │ │ └── body: (length: 1) - │ │ │ │ └── @ LocalVariableReadNode (location: (131,6)-(131,7)) + │ │ │ │ └── @ LocalVariableReadNode (location: (129,6)-(129,7)) │ │ │ │ ├── name: :a │ │ │ │ └── depth: 0 - │ │ │ ├── opening_loc: (130,8)-(130,10) = "do" - │ │ │ └── closing_loc: (132,4)-(132,7) = "end" - │ │ └── @ UntilNode (location: (134,2)-(137,5)) + │ │ │ ├── opening_loc: (128,8)-(128,10) = "do" + │ │ │ └── closing_loc: (130,4)-(130,7) = "end" + │ │ └── @ UntilNode (location: (132,2)-(135,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (134,2)-(134,7) = "until" - │ │ ├── closing_loc: (137,2)-(137,5) = "end" + │ │ ├── keyword_loc: (132,2)-(132,7) = "until" + │ │ ├── closing_loc: (135,2)-(135,5) = "end" │ │ ├── predicate: - │ │ │ @ CallNode (location: (134,8)-(134,9)) + │ │ │ @ CallNode (location: (132,8)-(132,9)) │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :x - │ │ │ ├── message_loc: (134,8)-(134,9) = "x" + │ │ │ ├── message_loc: (132,8)-(132,9) = "x" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: ∅ │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ │ │ └── statements: - │ │ @ StatementsNode (location: (135,4)-(136,7)) + │ │ @ StatementsNode (location: (133,4)-(134,7)) │ │ └── body: (length: 1) - │ │ └── @ CallNode (location: (135,4)-(136,7)) + │ │ └── @ CallNode (location: (133,4)-(134,7)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :baz - │ │ ├── message_loc: (135,4)-(135,7) = "baz" + │ │ ├── message_loc: (133,4)-(133,7) = "baz" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (135,8)-(136,7)) + │ │ @ BlockNode (location: (133,8)-(134,7)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: ∅ - │ │ ├── opening_loc: (135,8)-(135,10) = "do" - │ │ └── closing_loc: (136,4)-(136,7) = "end" + │ │ ├── opening_loc: (133,8)-(133,10) = "do" + │ │ └── closing_loc: (134,4)-(134,7) = "end" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (139,0)-(139,9)) + ├── @ CallNode (location: (137,0)-(137,9)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ HashNode (location: (139,0)-(139,2)) - │ │ ├── opening_loc: (139,0)-(139,1) = "{" + │ │ @ HashNode (location: (137,0)-(137,2)) + │ │ ├── opening_loc: (137,0)-(137,1) = "{" │ │ ├── elements: (length: 0) - │ │ └── closing_loc: (139,1)-(139,2) = "}" + │ │ └── closing_loc: (137,1)-(137,2) = "}" │ ├── call_operator_loc: ∅ │ ├── name: :+ - │ ├── message_loc: (139,3)-(139,4) = "+" + │ ├── message_loc: (137,3)-(137,4) = "+" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (139,5)-(139,9)) + │ │ @ ArgumentsNode (location: (137,5)-(137,9)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ CallNode (location: (139,5)-(139,9)) + │ │ └── @ CallNode (location: (137,5)-(137,9)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :A - │ │ ├── message_loc: (139,5)-(139,6) = "A" + │ │ ├── message_loc: (137,5)-(137,6) = "A" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (139,7)-(139,9)) + │ │ @ BlockNode (location: (137,7)-(137,9)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: ∅ - │ │ ├── opening_loc: (139,7)-(139,8) = "{" - │ │ └── closing_loc: (139,8)-(139,9) = "}" + │ │ ├── opening_loc: (137,7)-(137,8) = "{" + │ │ └── closing_loc: (137,8)-(137,9) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (141,0)-(141,16)) + ├── @ CallNode (location: (139,0)-(139,16)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ HashNode (location: (141,0)-(141,2)) - │ │ ├── opening_loc: (141,0)-(141,1) = "{" + │ │ @ HashNode (location: (139,0)-(139,2)) + │ │ ├── opening_loc: (139,0)-(139,1) = "{" │ │ ├── elements: (length: 0) - │ │ └── closing_loc: (141,1)-(141,2) = "}" + │ │ └── closing_loc: (139,1)-(139,2) = "}" │ ├── call_operator_loc: ∅ │ ├── name: :+ - │ ├── message_loc: (141,3)-(141,4) = "+" + │ ├── message_loc: (139,3)-(139,4) = "+" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (141,5)-(141,16)) + │ │ @ ArgumentsNode (location: (139,5)-(139,16)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ CallNode (location: (141,5)-(141,16)) + │ │ └── @ CallNode (location: (139,5)-(139,16)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :A - │ │ ├── message_loc: (141,5)-(141,6) = "A" + │ │ ├── message_loc: (139,5)-(139,6) = "A" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (141,7)-(141,16)) + │ │ @ BlockNode (location: (139,7)-(139,16)) │ │ ├── locals: [:a] │ │ ├── locals_body_index: 1 │ │ ├── parameters: - │ │ │ @ BlockParametersNode (location: (141,9)-(141,12)) + │ │ │ @ BlockParametersNode (location: (139,9)-(139,12)) │ │ │ ├── parameters: - │ │ │ │ @ ParametersNode (location: (141,10)-(141,11)) + │ │ │ │ @ ParametersNode (location: (139,10)-(139,11)) │ │ │ │ ├── requireds: (length: 1) - │ │ │ │ │ └── @ RequiredParameterNode (location: (141,10)-(141,11)) + │ │ │ │ │ └── @ RequiredParameterNode (location: (139,10)-(139,11)) │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ └── name: :a │ │ │ │ ├── optionals: (length: 0) @@ -2169,269 +2144,269 @@ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ └── block: ∅ │ │ │ ├── locals: (length: 0) - │ │ │ ├── opening_loc: (141,9)-(141,10) = "|" - │ │ │ └── closing_loc: (141,11)-(141,12) = "|" + │ │ │ ├── opening_loc: (139,9)-(139,10) = "|" + │ │ │ └── closing_loc: (139,11)-(139,12) = "|" │ │ ├── body: - │ │ │ @ StatementsNode (location: (141,13)-(141,14)) + │ │ │ @ StatementsNode (location: (139,13)-(139,14)) │ │ │ └── body: (length: 1) - │ │ │ └── @ LocalVariableReadNode (location: (141,13)-(141,14)) + │ │ │ └── @ LocalVariableReadNode (location: (139,13)-(139,14)) │ │ │ ├── name: :a │ │ │ └── depth: 0 - │ │ ├── opening_loc: (141,7)-(141,8) = "{" - │ │ └── closing_loc: (141,15)-(141,16) = "}" + │ │ ├── opening_loc: (139,7)-(139,8) = "{" + │ │ └── closing_loc: (139,15)-(139,16) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (143,0)-(143,11)) + ├── @ CallNode (location: (141,0)-(141,11)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (143,0)-(143,4)) + │ │ @ CallNode (location: (141,0)-(141,4)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :A - │ │ ├── message_loc: (143,0)-(143,1) = "A" + │ │ ├── message_loc: (141,0)-(141,1) = "A" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (143,2)-(143,4)) + │ │ @ BlockNode (location: (141,2)-(141,4)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: ∅ - │ │ ├── opening_loc: (143,2)-(143,3) = "{" - │ │ └── closing_loc: (143,3)-(143,4) = "}" + │ │ ├── opening_loc: (141,2)-(141,3) = "{" + │ │ └── closing_loc: (141,3)-(141,4) = "}" │ ├── call_operator_loc: ∅ │ ├── name: :+ - │ ├── message_loc: (143,5)-(143,6) = "+" + │ ├── message_loc: (141,5)-(141,6) = "+" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (143,7)-(143,11)) + │ │ @ ArgumentsNode (location: (141,7)-(141,11)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ CallNode (location: (143,7)-(143,11)) + │ │ └── @ CallNode (location: (141,7)-(141,11)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :A - │ │ ├── message_loc: (143,7)-(143,8) = "A" + │ │ ├── message_loc: (141,7)-(141,8) = "A" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (143,9)-(143,11)) + │ │ @ BlockNode (location: (141,9)-(141,11)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: ∅ - │ │ ├── opening_loc: (143,9)-(143,10) = "{" - │ │ └── closing_loc: (143,10)-(143,11) = "}" + │ │ ├── opening_loc: (141,9)-(141,10) = "{" + │ │ └── closing_loc: (141,10)-(141,11) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ CallNode (location: (145,0)-(145,11)) + ├── @ CallNode (location: (143,0)-(143,11)) │ ├── flags: ∅ │ ├── receiver: - │ │ @ CallNode (location: (145,0)-(145,3)) + │ │ @ CallNode (location: (143,0)-(143,3)) │ │ ├── flags: variable_call, ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :lst - │ │ ├── message_loc: (145,0)-(145,3) = "lst" + │ │ ├── message_loc: (143,0)-(143,3) = "lst" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :<< - │ ├── message_loc: (145,4)-(145,6) = "<<" + │ ├── message_loc: (143,4)-(143,6) = "<<" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (145,7)-(145,11)) + │ │ @ ArgumentsNode (location: (143,7)-(143,11)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 1) - │ │ └── @ CallNode (location: (145,7)-(145,11)) + │ │ └── @ CallNode (location: (143,7)-(143,11)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :A - │ │ ├── message_loc: (145,7)-(145,8) = "A" + │ │ ├── message_loc: (143,7)-(143,8) = "A" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (145,9)-(145,11)) + │ │ @ BlockNode (location: (143,9)-(143,11)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: ∅ - │ │ ├── opening_loc: (145,9)-(145,10) = "{" - │ │ └── closing_loc: (145,10)-(145,11) = "}" + │ │ ├── opening_loc: (143,9)-(143,10) = "{" + │ │ └── closing_loc: (143,10)-(143,11) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ InterpolatedStringNode (location: (147,0)-(147,17)) - │ ├── opening_loc: (147,0)-(147,1) = "\"" + ├── @ InterpolatedStringNode (location: (145,0)-(145,17)) + │ ├── opening_loc: (145,0)-(145,1) = "\"" │ ├── parts: (length: 1) - │ │ └── @ EmbeddedStatementsNode (location: (147,1)-(147,16)) - │ │ ├── opening_loc: (147,1)-(147,3) = "\#{" + │ │ └── @ EmbeddedStatementsNode (location: (145,1)-(145,16)) + │ │ ├── opening_loc: (145,1)-(145,3) = "\#{" │ │ ├── statements: - │ │ │ @ StatementsNode (location: (147,4)-(147,14)) + │ │ │ @ StatementsNode (location: (145,4)-(145,14)) │ │ │ └── body: (length: 1) - │ │ │ └── @ CallNode (location: (147,4)-(147,14)) + │ │ │ └── @ CallNode (location: (145,4)-(145,14)) │ │ │ ├── flags: ignore_visibility │ │ │ ├── receiver: ∅ │ │ │ ├── call_operator_loc: ∅ │ │ │ ├── name: :join - │ │ │ ├── message_loc: (147,4)-(147,8) = "join" + │ │ │ ├── message_loc: (145,4)-(145,8) = "join" │ │ │ ├── opening_loc: ∅ │ │ │ ├── arguments: - │ │ │ │ @ ArgumentsNode (location: (147,9)-(147,14)) + │ │ │ │ @ ArgumentsNode (location: (145,9)-(145,14)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── arguments: (length: 1) - │ │ │ │ └── @ ParenthesesNode (location: (147,9)-(147,14)) + │ │ │ │ └── @ ParenthesesNode (location: (145,9)-(145,14)) │ │ │ │ ├── body: - │ │ │ │ │ @ StatementsNode (location: (147,10)-(147,13)) + │ │ │ │ │ @ StatementsNode (location: (145,10)-(145,13)) │ │ │ │ │ └── body: (length: 1) - │ │ │ │ │ └── @ StringNode (location: (147,10)-(147,13)) + │ │ │ │ │ └── @ StringNode (location: (145,10)-(145,13)) │ │ │ │ │ ├── flags: ∅ - │ │ │ │ │ ├── opening_loc: (147,10)-(147,11) = "\"" - │ │ │ │ │ ├── content_loc: (147,11)-(147,12) = " " - │ │ │ │ │ ├── closing_loc: (147,12)-(147,13) = "\"" + │ │ │ │ │ ├── opening_loc: (145,10)-(145,11) = "\"" + │ │ │ │ │ ├── content_loc: (145,11)-(145,12) = " " + │ │ │ │ │ ├── closing_loc: (145,12)-(145,13) = "\"" │ │ │ │ │ └── unescaped: " " - │ │ │ │ ├── opening_loc: (147,9)-(147,10) = "(" - │ │ │ │ └── closing_loc: (147,13)-(147,14) = ")" + │ │ │ │ ├── opening_loc: (145,9)-(145,10) = "(" + │ │ │ │ └── closing_loc: (145,13)-(145,14) = ")" │ │ │ ├── closing_loc: ∅ │ │ │ └── block: ∅ - │ │ └── closing_loc: (147,15)-(147,16) = "}" - │ └── closing_loc: (147,16)-(147,17) = "\"" - ├── @ InterpolatedStringNode (location: (149,0)-(149,8)) - │ ├── opening_loc: (149,0)-(149,1) = "\"" + │ │ └── closing_loc: (145,15)-(145,16) = "}" + │ └── closing_loc: (145,16)-(145,17) = "\"" + ├── @ InterpolatedStringNode (location: (147,0)-(147,8)) + │ ├── opening_loc: (147,0)-(147,1) = "\"" │ ├── parts: (length: 1) - │ │ └── @ EmbeddedStatementsNode (location: (149,1)-(149,7)) - │ │ ├── opening_loc: (149,1)-(149,3) = "\#{" + │ │ └── @ EmbeddedStatementsNode (location: (147,1)-(147,7)) + │ │ ├── opening_loc: (147,1)-(147,3) = "\#{" │ │ ├── statements: - │ │ │ @ StatementsNode (location: (149,3)-(149,6)) + │ │ │ @ StatementsNode (location: (147,3)-(147,6)) │ │ │ └── body: (length: 1) - │ │ │ └── @ ParenthesesNode (location: (149,3)-(149,6)) + │ │ │ └── @ ParenthesesNode (location: (147,3)-(147,6)) │ │ │ ├── body: - │ │ │ │ @ StatementsNode (location: (149,4)-(149,5)) + │ │ │ │ @ StatementsNode (location: (147,4)-(147,5)) │ │ │ │ └── body: (length: 1) - │ │ │ │ └── @ CallNode (location: (149,4)-(149,5)) + │ │ │ │ └── @ CallNode (location: (147,4)-(147,5)) │ │ │ │ ├── flags: variable_call, ignore_visibility │ │ │ │ ├── receiver: ∅ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── name: :v - │ │ │ │ ├── message_loc: (149,4)-(149,5) = "v" + │ │ │ │ ├── message_loc: (147,4)-(147,5) = "v" │ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── arguments: ∅ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ └── block: ∅ - │ │ │ ├── opening_loc: (149,3)-(149,4) = "(" - │ │ │ └── closing_loc: (149,5)-(149,6) = ")" - │ │ └── closing_loc: (149,6)-(149,7) = "}" - │ └── closing_loc: (149,7)-(149,8) = "\"" - ├── @ DefNode (location: (151,0)-(151,18)) + │ │ │ ├── opening_loc: (147,3)-(147,4) = "(" + │ │ │ └── closing_loc: (147,5)-(147,6) = ")" + │ │ └── closing_loc: (147,6)-(147,7) = "}" + │ └── closing_loc: (147,7)-(147,8) = "\"" + ├── @ DefNode (location: (149,0)-(149,18)) │ ├── name: :f - │ ├── name_loc: (151,4)-(151,5) = "f" + │ ├── name_loc: (149,4)-(149,5) = "f" │ ├── receiver: ∅ │ ├── parameters: - │ │ @ ParametersNode (location: (151,6)-(151,7)) + │ │ @ ParametersNode (location: (149,6)-(149,7)) │ │ ├── requireds: (length: 0) │ │ ├── optionals: (length: 0) │ │ ├── rest: - │ │ │ @ RestParameterNode (location: (151,6)-(151,7)) + │ │ │ @ RestParameterNode (location: (149,6)-(149,7)) │ │ │ ├── flags: ∅ │ │ │ ├── name: ∅ │ │ │ ├── name_loc: ∅ - │ │ │ └── operator_loc: (151,6)-(151,7) = "*" + │ │ │ └── operator_loc: (149,6)-(149,7) = "*" │ │ ├── posts: (length: 0) │ │ ├── keywords: (length: 0) │ │ ├── keyword_rest: ∅ │ │ └── block: ∅ │ ├── body: - │ │ @ StatementsNode (location: (151,10)-(151,13)) + │ │ @ StatementsNode (location: (149,10)-(149,13)) │ │ └── body: (length: 1) - │ │ └── @ CallNode (location: (151,10)-(151,13)) + │ │ └── @ CallNode (location: (149,10)-(149,13)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :p - │ │ ├── message_loc: (151,10)-(151,11) = "p" + │ │ ├── message_loc: (149,10)-(149,11) = "p" │ │ ├── opening_loc: ∅ │ │ ├── arguments: - │ │ │ @ ArgumentsNode (location: (151,12)-(151,13)) + │ │ │ @ ArgumentsNode (location: (149,12)-(149,13)) │ │ │ ├── flags: ∅ │ │ │ └── arguments: (length: 1) - │ │ │ └── @ SplatNode (location: (151,12)-(151,13)) - │ │ │ ├── operator_loc: (151,12)-(151,13) = "*" + │ │ │ └── @ SplatNode (location: (149,12)-(149,13)) + │ │ │ ├── operator_loc: (149,12)-(149,13) = "*" │ │ │ └── expression: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: ∅ │ ├── locals: [:*] │ ├── locals_body_index: 1 - │ ├── def_keyword_loc: (151,0)-(151,3) = "def" + │ ├── def_keyword_loc: (149,0)-(149,3) = "def" │ ├── operator_loc: ∅ - │ ├── lparen_loc: (151,5)-(151,6) = "(" - │ ├── rparen_loc: (151,7)-(151,8) = ")" + │ ├── lparen_loc: (149,5)-(149,6) = "(" + │ ├── rparen_loc: (149,7)-(149,8) = ")" │ ├── equal_loc: ∅ - │ └── end_keyword_loc: (151,15)-(151,18) = "end" - ├── @ CallNode (location: (153,0)-(153,16)) + │ └── end_keyword_loc: (149,15)-(149,18) = "end" + ├── @ CallNode (location: (151,0)-(151,16)) │ ├── flags: ignore_visibility │ ├── receiver: ∅ │ ├── call_operator_loc: ∅ │ ├── name: :foo - │ ├── message_loc: (153,0)-(153,3) = "foo" + │ ├── message_loc: (151,0)-(151,3) = "foo" │ ├── opening_loc: ∅ │ ├── arguments: - │ │ @ ArgumentsNode (location: (153,4)-(153,16)) + │ │ @ ArgumentsNode (location: (151,4)-(151,16)) │ │ ├── flags: ∅ │ │ └── arguments: (length: 2) - │ │ ├── @ IntegerNode (location: (153,4)-(153,5)) + │ │ ├── @ IntegerNode (location: (151,4)-(151,5)) │ │ │ └── flags: decimal - │ │ └── @ CallNode (location: (153,7)-(153,16)) + │ │ └── @ CallNode (location: (151,7)-(151,16)) │ │ ├── flags: ignore_visibility │ │ ├── receiver: ∅ │ │ ├── call_operator_loc: ∅ │ │ ├── name: :Bar - │ │ ├── message_loc: (153,7)-(153,10) = "Bar" + │ │ ├── message_loc: (151,7)-(151,10) = "Bar" │ │ ├── opening_loc: ∅ │ │ ├── arguments: ∅ │ │ ├── closing_loc: ∅ │ │ └── block: - │ │ @ BlockNode (location: (153,11)-(153,16)) + │ │ @ BlockNode (location: (151,11)-(151,16)) │ │ ├── locals: [] │ │ ├── locals_body_index: 0 │ │ ├── parameters: ∅ │ │ ├── body: - │ │ │ @ StatementsNode (location: (153,13)-(153,14)) + │ │ │ @ StatementsNode (location: (151,13)-(151,14)) │ │ │ └── body: (length: 1) - │ │ │ └── @ IntegerNode (location: (153,13)-(153,14)) + │ │ │ └── @ IntegerNode (location: (151,13)-(151,14)) │ │ │ └── flags: decimal - │ │ ├── opening_loc: (153,11)-(153,12) = "{" - │ │ └── closing_loc: (153,15)-(153,16) = "}" + │ │ ├── opening_loc: (151,11)-(151,12) = "{" + │ │ └── closing_loc: (151,15)-(151,16) = "}" │ ├── closing_loc: ∅ │ └── block: ∅ - ├── @ LocalVariableWriteNode (location: (155,0)-(155,7)) + ├── @ LocalVariableWriteNode (location: (153,0)-(153,7)) │ ├── name: :foo │ ├── depth: 0 - │ ├── name_loc: (155,0)-(155,3) = "foo" + │ ├── name_loc: (153,0)-(153,3) = "foo" │ ├── value: - │ │ @ IntegerNode (location: (155,6)-(155,7)) + │ │ @ IntegerNode (location: (153,6)-(153,7)) │ │ └── flags: decimal - │ └── operator_loc: (155,4)-(155,5) = "=" - └── @ CallNode (location: (156,0)-(156,6)) + │ └── operator_loc: (153,4)-(153,5) = "=" + └── @ CallNode (location: (154,0)-(154,6)) ├── flags: ignore_visibility ├── receiver: ∅ ├── call_operator_loc: ∅ ├── name: :foo - ├── message_loc: (156,0)-(156,3) = "foo" + ├── message_loc: (154,0)-(154,3) = "foo" ├── opening_loc: ∅ ├── arguments: ∅ ├── closing_loc: ∅ └── block: - @ BlockNode (location: (156,4)-(156,6)) + @ BlockNode (location: (154,4)-(154,6)) ├── locals: [] ├── locals_body_index: 0 ├── parameters: ∅ ├── body: ∅ - ├── opening_loc: (156,4)-(156,5) = "{" - └── closing_loc: (156,5)-(156,6) = "}" + ├── opening_loc: (154,4)-(154,5) = "{" + └── closing_loc: (154,5)-(154,6) = "}" |