archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-09-21 11:33:58 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

[ruby/yarp] Print locations using line / col instead of offsets

Browse source 
This commit changes printing of locations to use the format
(start_line,start_column)-(end_line,end_column) instead of using
offsets.

c078696e22
This commit is contained in:
Jemma Issroff 2023-09-19 11:46:04 -04:00 • committed by git
parent 0a630fa461
commit d6abca459f
912 changed files with 30188 additions and 30188 deletions
Download patch file Download diff file Expand all files Collapse all files

8
lib/yarp.rb
View file

@ -71,7 +71,7 @@ module YARP
# Returns a string representation of this location. # Returns a string representation of this location.
def inspect def inspect
"#<YARP::Location @start_offset=#{@start_offset} @length=#{@length}>" "#<YARP::Location @start_offset=#{@start_offset} @length=#{@length} start_line=#{start_line}>"
end end
# The source code that this location represents. # The source code that this location represents.
@ -117,7 +117,7 @@ module YARP
end end
def pretty_print(q) def pretty_print(q)
q.text("(#{start_offset}...#{end_offset})") q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column}))")
end end
def ==(other) def ==(other)
@ -333,7 +333,7 @@ module YARP
# for any given node. # for any given node.
def header(node) def header(node)
output = +"@ #{node.class.name.split("::").last} (" output = +"@ #{node.class.name.split("::").last} ("
output << "location: (#{node.location.start_offset}...#{node.location.end_offset})" output << "location: (#{node.location.start_line},#{node.location.start_column})-(#{node.location.end_line},#{node.location.end_column})"
output << ", newline: true" if node.newline? output << ", newline: true" if node.newline?
output << ")\n" output << ")\n"
output output
@ -357,7 +357,7 @@ module YARP
# Generates a string that represents a location field on a node. # Generates a string that represents a location field on a node.
def location(value) def location(value)
if value if value
"(#{value.start_offset}...#{value.end_offset}) = #{value.slice.inspect}" "(#{value.start_line},#{value.start_column})-(#{value.end_line},#{value.end_column}) = #{value.slice.inspect}"
else else
"∅" "∅"
end end

188
test/yarp/snapshots/alias.txt
View file

@ -1,173 +1,173 @@
@ ProgramNode (location: (0...199)) @ ProgramNode (location: (1,0)-(23,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...199)) @ StatementsNode (location: (1,0)-(23,11))
└── body: (length: 12) └── body: (length: 12)
├── @ AliasMethodNode (location: (0...15)) ├── @ AliasMethodNode (location: (1,0)-(1,15))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (6...10)) │ │ @ SymbolNode (location: (1,6)-(1,10))
│ │ ├── opening_loc: (6...7) = ":" │ │ ├── opening_loc: (1,6)-(1,7) = ":"
│ │ ├── value_loc: (7...10) = "foo" │ │ ├── value_loc: (1,7)-(1,10) = "foo"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo" │ │ └── unescaped: "foo"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (11...15)) │ │ @ SymbolNode (location: (1,11)-(1,15))
│ │ ├── opening_loc: (11...12) = ":" │ │ ├── opening_loc: (1,11)-(1,12) = ":"
│ │ ├── value_loc: (12...15) = "bar" │ │ ├── value_loc: (1,12)-(1,15) = "bar"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "bar" │ │ └── unescaped: "bar"
│ └── keyword_loc: (0...5) = "alias" │ └── keyword_loc: (1,0)-(1,5) = "alias"
├── @ AliasMethodNode (location: (17...38)) ├── @ AliasMethodNode (location: (3,0)-(3,21))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (23...30)) │ │ @ SymbolNode (location: (3,6)-(3,13))
│ │ ├── opening_loc: (23...26) = "%s[" │ │ ├── opening_loc: (3,6)-(3,9) = "%s["
│ │ ├── value_loc: (26...29) = "abc" │ │ ├── value_loc: (3,9)-(3,12) = "abc"
│ │ ├── closing_loc: (29...30) = "]" │ │ ├── closing_loc: (3,12)-(3,13) = "]"
│ │ └── unescaped: "abc" │ │ └── unescaped: "abc"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (31...38)) │ │ @ SymbolNode (location: (3,14)-(3,21))
│ │ ├── opening_loc: (31...34) = "%s[" │ │ ├── opening_loc: (3,14)-(3,17) = "%s["
│ │ ├── value_loc: (34...37) = "def" │ │ ├── value_loc: (3,17)-(3,20) = "def"
│ │ ├── closing_loc: (37...38) = "]" │ │ ├── closing_loc: (3,20)-(3,21) = "]"
│ │ └── unescaped: "def" │ │ └── unescaped: "def"
│ └── keyword_loc: (17...22) = "alias" │ └── keyword_loc: (3,0)-(3,5) = "alias"
├── @ AliasMethodNode (location: (40...59)) ├── @ AliasMethodNode (location: (5,0)-(5,19))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (46...52)) │ │ @ SymbolNode (location: (5,6)-(5,12))
│ │ ├── opening_loc: (46...48) = ":'" │ │ ├── opening_loc: (5,6)-(5,8) = ":'"
│ │ ├── value_loc: (48...51) = "abc" │ │ ├── value_loc: (5,8)-(5,11) = "abc"
│ │ ├── closing_loc: (51...52) = "'" │ │ ├── closing_loc: (5,11)-(5,12) = "'"
│ │ └── unescaped: "abc" │ │ └── unescaped: "abc"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (53...59)) │ │ @ SymbolNode (location: (5,13)-(5,19))
│ │ ├── opening_loc: (53...55) = ":'" │ │ ├── opening_loc: (5,13)-(5,15) = ":'"
│ │ ├── value_loc: (55...58) = "def" │ │ ├── value_loc: (5,15)-(5,18) = "def"
│ │ ├── closing_loc: (58...59) = "'" │ │ ├── closing_loc: (5,18)-(5,19) = "'"
│ │ └── unescaped: "def" │ │ └── unescaped: "def"
│ └── keyword_loc: (40...45) = "alias" │ └── keyword_loc: (5,0)-(5,5) = "alias"
├── @ AliasMethodNode (location: (61...84)) ├── @ AliasMethodNode (location: (7,0)-(7,23))
│ ├── new_name: │ ├── new_name:
│ │ @ InterpolatedSymbolNode (location: (67...77)) │ │ @ InterpolatedSymbolNode (location: (7,6)-(7,16))
│ │ ├── opening_loc: (67...69) = ":\"" │ │ ├── opening_loc: (7,6)-(7,8) = ":\""
│ │ ├── parts: (length: 2) │ │ ├── parts: (length: 2)
│ │ │ ├── @ StringNode (location: (69...72)) │ │ │ ├── @ StringNode (location: (7,8)-(7,11))
│ │ │ │ ├── flags: ∅ │ │ │ │ ├── flags: ∅
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── content_loc: (69...72) = "abc" │ │ │ │ ├── content_loc: (7,8)-(7,11) = "abc"
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "abc" │ │ │ │ └── unescaped: "abc"
│ │ │ └── @ EmbeddedStatementsNode (location: (72...76)) │ │ │ └── @ EmbeddedStatementsNode (location: (7,11)-(7,15))
│ │ │ ├── opening_loc: (72...74) = "\#{" │ │ │ ├── opening_loc: (7,11)-(7,13) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (74...75)) │ │ │ │ @ StatementsNode (location: (7,13)-(7,14))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (74...75)) │ │ │ │ └── @ IntegerNode (location: (7,13)-(7,14))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── closing_loc: (75...76) = "}" │ │ │ └── closing_loc: (7,14)-(7,15) = "}"
│ │ └── closing_loc: (76...77) = "\"" │ │ └── closing_loc: (7,15)-(7,16) = "\""
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (78...84)) │ │ @ SymbolNode (location: (7,17)-(7,23))
│ │ ├── opening_loc: (78...80) = ":'" │ │ ├── opening_loc: (7,17)-(7,19) = ":'"
│ │ ├── value_loc: (80...83) = "def" │ │ ├── value_loc: (7,19)-(7,22) = "def"
│ │ ├── closing_loc: (83...84) = "'" │ │ ├── closing_loc: (7,22)-(7,23) = "'"
│ │ └── unescaped: "def" │ │ └── unescaped: "def"
│ └── keyword_loc: (61...66) = "alias" │ └── keyword_loc: (7,0)-(7,5) = "alias"
├── @ AliasGlobalVariableNode (location: (86...97)) ├── @ AliasGlobalVariableNode (location: (9,0)-(9,11))
│ ├── new_name: │ ├── new_name:
│ │ @ GlobalVariableReadNode (location: (92...94)) │ │ @ GlobalVariableReadNode (location: (9,6)-(9,8))
│ │ └── name: :$a │ │ └── name: :$a
│ ├── old_name: │ ├── old_name:
│ │ @ BackReferenceReadNode (location: (95...97)) │ │ @ BackReferenceReadNode (location: (9,9)-(9,11))
│ └── keyword_loc: (86...91) = "alias" │ └── keyword_loc: (9,0)-(9,5) = "alias"
├── @ AliasMethodNode (location: (99...112)) ├── @ AliasMethodNode (location: (11,0)-(11,13))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (105...108)) │ │ @ SymbolNode (location: (11,6)-(11,9))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (105...108) = "foo" │ │ ├── value_loc: (11,6)-(11,9) = "foo"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo" │ │ └── unescaped: "foo"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (109...112)) │ │ @ SymbolNode (location: (11,10)-(11,13))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (109...112) = "bar" │ │ ├── value_loc: (11,10)-(11,13) = "bar"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "bar" │ │ └── unescaped: "bar"
│ └── keyword_loc: (99...104) = "alias" │ └── keyword_loc: (11,0)-(11,5) = "alias"
├── @ AliasGlobalVariableNode (location: (114...129)) ├── @ AliasGlobalVariableNode (location: (13,0)-(13,15))
│ ├── new_name: │ ├── new_name:
│ │ @ GlobalVariableReadNode (location: (120...124)) │ │ @ GlobalVariableReadNode (location: (13,6)-(13,10))
│ │ └── name: :$foo │ │ └── name: :$foo
│ ├── old_name: │ ├── old_name:
│ │ @ GlobalVariableReadNode (location: (125...129)) │ │ @ GlobalVariableReadNode (location: (13,11)-(13,15))
│ │ └── name: :$bar │ │ └── name: :$bar
│ └── keyword_loc: (114...119) = "alias" │ └── keyword_loc: (13,0)-(13,5) = "alias"
├── @ AliasMethodNode (location: (131...143)) ├── @ AliasMethodNode (location: (15,0)-(15,12))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (137...140)) │ │ @ SymbolNode (location: (15,6)-(15,9))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (137...140) = "foo" │ │ ├── value_loc: (15,6)-(15,9) = "foo"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo" │ │ └── unescaped: "foo"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (141...143)) │ │ @ SymbolNode (location: (15,10)-(15,12))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (141...143) = "if" │ │ ├── value_loc: (15,10)-(15,12) = "if"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "if" │ │ └── unescaped: "if"
│ └── keyword_loc: (131...136) = "alias" │ └── keyword_loc: (15,0)-(15,5) = "alias"
├── @ AliasMethodNode (location: (145...158)) ├── @ AliasMethodNode (location: (17,0)-(17,13))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (151...154)) │ │ @ SymbolNode (location: (17,6)-(17,9))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (151...154) = "foo" │ │ ├── value_loc: (17,6)-(17,9) = "foo"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo" │ │ └── unescaped: "foo"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (155...158)) │ │ @ SymbolNode (location: (17,10)-(17,13))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (155...158) = "<=>" │ │ ├── value_loc: (17,10)-(17,13) = "<=>"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "<=>" │ │ └── unescaped: "<=>"
│ └── keyword_loc: (145...150) = "alias" │ └── keyword_loc: (17,0)-(17,5) = "alias"
├── @ AliasMethodNode (location: (160...175)) ├── @ AliasMethodNode (location: (19,0)-(19,15))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (166...169)) │ │ @ SymbolNode (location: (19,6)-(19,9))
│ │ ├── opening_loc: (166...167) = ":" │ │ ├── opening_loc: (19,6)-(19,7) = ":"
│ │ ├── value_loc: (167...169) = "==" │ │ ├── value_loc: (19,7)-(19,9) = "=="
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "==" │ │ └── unescaped: "=="
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (170...175)) │ │ @ SymbolNode (location: (19,10)-(19,15))
│ │ ├── opening_loc: (170...171) = ":" │ │ ├── opening_loc: (19,10)-(19,11) = ":"
│ │ ├── value_loc: (171...175) = "eql?" │ │ ├── value_loc: (19,11)-(19,15) = "eql?"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "eql?" │ │ └── unescaped: "eql?"
│ └── keyword_loc: (160...165) = "alias" │ └── keyword_loc: (19,0)-(19,5) = "alias"
├── @ AliasMethodNode (location: (177...186)) ├── @ AliasMethodNode (location: (21,0)-(21,9))
│ ├── new_name: │ ├── new_name:
│ │ @ SymbolNode (location: (183...184)) │ │ @ SymbolNode (location: (21,6)-(21,7))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (183...184) = "A" │ │ ├── value_loc: (21,6)-(21,7) = "A"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "A" │ │ └── unescaped: "A"
│ ├── old_name: │ ├── old_name:
│ │ @ SymbolNode (location: (185...186)) │ │ @ SymbolNode (location: (21,8)-(21,9))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (185...186) = "B" │ │ ├── value_loc: (21,8)-(21,9) = "B"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "B" │ │ └── unescaped: "B"
│ └── keyword_loc: (177...182) = "alias" │ └── keyword_loc: (21,0)-(21,5) = "alias"
└── @ AliasMethodNode (location: (188...199)) └── @ AliasMethodNode (location: (23,0)-(23,11))
├── new_name: ├── new_name:
│ @ SymbolNode (location: (194...196)) │ @ SymbolNode (location: (23,6)-(23,8))
│ ├── opening_loc: (194...195) = ":" │ ├── opening_loc: (23,6)-(23,7) = ":"
│ ├── value_loc: (195...196) = "A" │ ├── value_loc: (23,7)-(23,8) = "A"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "A" │ └── unescaped: "A"
├── old_name: ├── old_name:
│ @ SymbolNode (location: (197...199)) │ @ SymbolNode (location: (23,9)-(23,11))
│ ├── opening_loc: (197...198) = ":" │ ├── opening_loc: (23,9)-(23,10) = ":"
│ ├── value_loc: (198...199) = "B" │ ├── value_loc: (23,10)-(23,11) = "B"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "B" │ └── unescaped: "B"
└── keyword_loc: (188...193) = "alias" └── keyword_loc: (23,0)-(23,5) = "alias"

114
test/yarp/snapshots/arithmetic.txt
View file

@ -1,22 +1,22 @@
@ ProgramNode (location: (0...75)) @ ProgramNode (location: (1,0)-(13,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...75)) @ StatementsNode (location: (1,0)-(13,8))
└── body: (length: 7) └── body: (length: 7)
├── @ CallNode (location: (0...8)) ├── @ CallNode (location: (1,0)-(1,8))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...3) = "foo" │ ├── message_loc: (1,0)-(1,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...8)) │ │ @ ArgumentsNode (location: (1,4)-(1,8))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...8)) │ │ └── @ CallNode (location: (1,4)-(1,8))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (5...8)) │ │ │ @ CallNode (location: (1,5)-(1,8))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (5...8) = "bar" │ │ │ ├── message_loc: (1,5)-(1,8) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -24,7 +24,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "!" │ │ ├── message_loc: (1,4)-(1,5) = "!"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -35,14 +35,14 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (10...18)) ├── @ CallNode (location: (3,0)-(3,8))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (10...14)) │ │ @ CallNode (location: (3,0)-(3,4))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (11...14)) │ │ │ @ CallNode (location: (3,1)-(3,4))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...14) = "foo" │ │ │ ├── message_loc: (3,1)-(3,4) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -50,7 +50,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (10...11) = "-" │ │ ├── message_loc: (3,0)-(3,1) = "-"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -58,15 +58,15 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "-@" │ │ └── name: "-@"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (14...15) = "*" │ ├── message_loc: (3,4)-(3,5) = "*"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (15...18)) │ │ @ ArgumentsNode (location: (3,5)-(3,8))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (15...18)) │ │ └── @ CallNode (location: (3,5)-(3,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (15...18) = "bar" │ │ ├── message_loc: (3,5)-(3,8) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -77,14 +77,14 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "*" │ └── name: "*"
├── @ CallNode (location: (20...29)) ├── @ CallNode (location: (5,0)-(5,9))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (20...24)) │ │ @ CallNode (location: (5,0)-(5,4))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (21...24)) │ │ │ @ CallNode (location: (5,1)-(5,4))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (21...24) = "foo" │ │ │ ├── message_loc: (5,1)-(5,4) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -92,7 +92,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (20...21) = "+" │ │ ├── message_loc: (5,0)-(5,1) = "+"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -100,15 +100,15 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "+@" │ │ └── name: "+@"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (24...26) = "**" │ ├── message_loc: (5,4)-(5,6) = "**"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (26...29)) │ │ @ ArgumentsNode (location: (5,6)-(5,9))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (26...29)) │ │ └── @ CallNode (location: (5,6)-(5,9))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (26...29) = "bar" │ │ ├── message_loc: (5,6)-(5,9) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -119,20 +119,20 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "**" │ └── name: "**"
├── @ CallNode (location: (31...39)) ├── @ CallNode (location: (7,0)-(7,8))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (31...34) = "foo" │ ├── message_loc: (7,0)-(7,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (35...39)) │ │ @ ArgumentsNode (location: (7,4)-(7,8))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (35...39)) │ │ └── @ CallNode (location: (7,4)-(7,8))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (36...39)) │ │ │ @ CallNode (location: (7,5)-(7,8))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (36...39) = "bar" │ │ │ ├── message_loc: (7,5)-(7,8) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -140,7 +140,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (35...36) = "~" │ │ ├── message_loc: (7,4)-(7,5) = "~"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -151,14 +151,14 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (41...58)) ├── @ CallNode (location: (9,0)-(9,17))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (41...51)) │ │ @ CallNode (location: (9,0)-(9,10))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (41...44)) │ │ │ @ CallNode (location: (9,0)-(9,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (41...44) = "foo" │ │ │ ├── message_loc: (9,0)-(9,3) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -166,15 +166,15 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (45...47) = "<<" │ │ ├── message_loc: (9,4)-(9,6) = "<<"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (48...51)) │ │ │ @ ArgumentsNode (location: (9,7)-(9,10))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ CallNode (location: (48...51)) │ │ │ └── @ CallNode (location: (9,7)-(9,10))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (48...51) = "bar" │ │ │ ├── message_loc: (9,7)-(9,10) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -186,15 +186,15 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "<<" │ │ └── name: "<<"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (52...54) = "<<" │ ├── message_loc: (9,11)-(9,13) = "<<"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (55...58)) │ │ @ ArgumentsNode (location: (9,14)-(9,17))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (55...58)) │ │ └── @ CallNode (location: (9,14)-(9,17))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (55...58) = "baz" │ │ ├── message_loc: (9,14)-(9,17) = "baz"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -205,38 +205,38 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "<<" │ └── name: "<<"
├── @ CallNode (location: (60...65)) ├── @ CallNode (location: (11,0)-(11,5))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (61...65)) │ │ @ CallNode (location: (11,1)-(11,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (61...62)) │ │ │ @ IntegerNode (location: (11,1)-(11,2))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (62...64) = "**" │ │ ├── message_loc: (11,2)-(11,4) = "**"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (64...65)) │ │ │ @ ArgumentsNode (location: (11,4)-(11,5))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (64...65)) │ │ │ └── @ IntegerNode (location: (11,4)-(11,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "**" │ │ └── name: "**"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (60...61) = "-" │ ├── message_loc: (11,0)-(11,1) = "-"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "-@" │ └── name: "-@"
└── @ CallNode (location: (67...75)) └── @ CallNode (location: (13,0)-(13,8))
├── receiver: ├── receiver:
│ @ IntegerNode (location: (67...69)) │ @ IntegerNode (location: (13,0)-(13,2))
│ └── flags: decimal │ └── flags: decimal
├── call_operator_loc: (69...70) = "." ├── call_operator_loc: (13,2)-(13,3) = "."
├── message_loc: (70...75) = "zero?" ├── message_loc: (13,3)-(13,8) = "zero?"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

656
test/yarp/snapshots/arrays.txt
View file

File diff suppressed because it is too large Load diff

194
test/yarp/snapshots/begin_ensure.txt
View file

@ -1,17 +1,17 @@
@ ProgramNode (location: (0...211)) @ ProgramNode (location: (1,0)-(21,15))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...211)) @ StatementsNode (location: (1,0)-(21,15))
└── body: (length: 5) └── body: (length: 5)
├── @ BeginNode (location: (0...20)) ├── @ BeginNode (location: (1,0)-(5,3))
│ ├── begin_keyword_loc: (0...5) = "begin" │ ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (6...7)) │ │ @ StatementsNode (location: (2,0)-(2,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (6...7)) │ │ └── @ CallNode (location: (2,0)-(2,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (6...7) = "a" │ │ ├── message_loc: (2,0)-(2,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -21,32 +21,32 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (8...20)) │ │ @ EnsureNode (location: (3,0)-(5,3))
│ │ ├── ensure_keyword_loc: (8...14) = "ensure" │ │ ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (15...16)) │ │ │ @ StatementsNode (location: (4,0)-(4,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (15...16)) │ │ │ └── @ CallNode (location: (4,0)-(4,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (15...16) = "b" │ │ │ ├── message_loc: (4,0)-(4,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── end_keyword_loc: (17...20) = "end" │ │ └── end_keyword_loc: (5,0)-(5,3) = "end"
│ └── end_keyword_loc: (17...20) = "end" │ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ BeginNode (location: (22...46)) ├── @ BeginNode (location: (7,0)-(7,24))
│ ├── begin_keyword_loc: (22...27) = "begin" │ ├── begin_keyword_loc: (7,0)-(7,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (29...30)) │ │ @ StatementsNode (location: (7,7)-(7,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (29...30)) │ │ └── @ CallNode (location: (7,7)-(7,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (29...30) = "a" │ │ ├── message_loc: (7,7)-(7,8) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -56,32 +56,32 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (32...46)) │ │ @ EnsureNode (location: (7,10)-(7,24))
│ │ ├── ensure_keyword_loc: (32...38) = "ensure" │ │ ├── ensure_keyword_loc: (7,10)-(7,16) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (40...41)) │ │ │ @ StatementsNode (location: (7,18)-(7,19))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (40...41)) │ │ │ └── @ CallNode (location: (7,18)-(7,19))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (40...41) = "b" │ │ │ ├── message_loc: (7,18)-(7,19) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── end_keyword_loc: (43...46) = "end" │ │ └── end_keyword_loc: (7,21)-(7,24) = "end"
│ └── end_keyword_loc: (43...46) = "end" │ └── end_keyword_loc: (7,21)-(7,24) = "end"
├── @ BeginNode (location: (48...70)) ├── @ BeginNode (location: (9,0)-(11,4))
│ ├── begin_keyword_loc: (48...53) = "begin" │ ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (54...55)) │ │ @ StatementsNode (location: (9,6)-(9,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (54...55)) │ │ └── @ CallNode (location: (9,6)-(9,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (54...55) = "a" │ │ ├── message_loc: (9,6)-(9,7) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -91,32 +91,32 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (57...70)) │ │ @ EnsureNode (location: (10,1)-(11,4))
│ │ ├── ensure_keyword_loc: (57...63) = "ensure" │ │ ├── ensure_keyword_loc: (10,1)-(10,7) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (64...65)) │ │ │ @ StatementsNode (location: (10,8)-(10,9))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (64...65)) │ │ │ └── @ CallNode (location: (10,8)-(10,9))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (64...65) = "b" │ │ │ ├── message_loc: (10,8)-(10,9) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── end_keyword_loc: (67...70) = "end" │ │ └── end_keyword_loc: (11,1)-(11,4) = "end"
│ └── end_keyword_loc: (67...70) = "end" │ └── end_keyword_loc: (11,1)-(11,4) = "end"
├── @ BeginNode (location: (72...94)) ├── @ BeginNode (location: (13,0)-(13,22))
│ ├── begin_keyword_loc: (72...77) = "begin" │ ├── begin_keyword_loc: (13,0)-(13,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (78...79)) │ │ @ StatementsNode (location: (13,6)-(13,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (78...79)) │ │ └── @ CallNode (location: (13,6)-(13,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (78...79) = "a" │ │ ├── message_loc: (13,6)-(13,7) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -126,115 +126,115 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (81...94)) │ │ @ EnsureNode (location: (13,9)-(13,22))
│ │ ├── ensure_keyword_loc: (81...87) = "ensure" │ │ ├── ensure_keyword_loc: (13,9)-(13,15) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (88...89)) │ │ │ @ StatementsNode (location: (13,16)-(13,17))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (88...89)) │ │ │ └── @ CallNode (location: (13,16)-(13,17))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (88...89) = "b" │ │ │ ├── message_loc: (13,16)-(13,17) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── end_keyword_loc: (91...94) = "end" │ │ └── end_keyword_loc: (13,19)-(13,22) = "end"
│ └── end_keyword_loc: (91...94) = "end" │ └── end_keyword_loc: (13,19)-(13,22) = "end"
└── @ BeginNode (location: (96...211)) └── @ BeginNode (location: (15,0)-(21,15))
├── begin_keyword_loc: (96...101) = "begin" ├── begin_keyword_loc: (15,0)-(15,5) = "begin"
├── statements: ├── statements:
│ @ StatementsNode (location: (102...207)) │ @ StatementsNode (location: (15,6)-(21,11))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ BeginNode (location: (102...207)) │ └── @ BeginNode (location: (15,6)-(21,11))
│ ├── begin_keyword_loc: (102...107) = "begin" │ ├── begin_keyword_loc: (15,6)-(15,11) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (107...203)) │ │ @ StatementsNode (location: (15,11)-(21,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (107...203)) │ │ └── @ CallNode (location: (15,11)-(21,7))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ SymbolNode (location: (107...109)) │ │ │ @ SymbolNode (location: (15,11)-(15,13))
│ │ │ ├── opening_loc: (107...108) = ":" │ │ │ ├── opening_loc: (15,11)-(15,12) = ":"
│ │ │ ├── value_loc: (108...109) = "s" │ │ │ ├── value_loc: (15,12)-(15,13) = "s"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "s" │ │ │ └── unescaped: "s"
│ │ ├── call_operator_loc: (109...110) = "." │ │ ├── call_operator_loc: (15,13)-(15,14) = "."
│ │ ├── message_loc: (110...111) = "l" │ │ ├── message_loc: (15,14)-(15,15) = "l"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (112...203)) │ │ │ @ ArgumentsNode (location: (15,16)-(21,7))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ BeginNode (location: (112...203)) │ │ │ └── @ BeginNode (location: (15,16)-(21,7))
│ │ │ ├── begin_keyword_loc: (112...117) = "begin" │ │ │ ├── begin_keyword_loc: (15,16)-(15,21) = "begin"
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: ∅ │ │ │ ├── rescue_clause: ∅
│ │ │ ├── else_clause: ∅ │ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause: │ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (118...203)) │ │ │ │ @ EnsureNode (location: (15,22)-(21,7))
│ │ │ │ ├── ensure_keyword_loc: (118...124) = "ensure" │ │ │ │ ├── ensure_keyword_loc: (15,22)-(15,28) = "ensure"
│ │ │ │ ├── statements: │ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (125...199)) │ │ │ │ │ @ StatementsNode (location: (15,29)-(21,3))
│ │ │ │ │ └── body: (length: 1) │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (125...199)) │ │ │ │ │ └── @ CallNode (location: (15,29)-(21,3))
│ │ │ │ │ ├── receiver: │ │ │ │ │ ├── receiver:
│ │ │ │ │ │ @ ConstantReadNode (location: (125...131)) │ │ │ │ │ │ @ ConstantReadNode (location: (15,29)-(15,35))
│ │ │ │ │ │ └── name: :Module │ │ │ │ │ │ └── name: :Module
│ │ │ │ │ ├── call_operator_loc: (131...132) = "." │ │ │ │ │ ├── call_operator_loc: (15,35)-(15,36) = "."
│ │ │ │ │ ├── message_loc: (132...135) = "new" │ │ │ │ │ ├── message_loc: (15,36)-(15,39) = "new"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block: │ │ │ │ │ ├── block:
│ │ │ │ │ │ @ BlockNode (location: (136...199)) │ │ │ │ │ │ @ BlockNode (location: (15,40)-(21,3))
│ │ │ │ │ │ ├── locals: [] │ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ ├── body: │ │ │ │ │ │ ├── body:
│ │ │ │ │ │ │ @ StatementsNode (location: (141...195)) │ │ │ │ │ │ │ @ StatementsNode (location: (16,2)-(20,5))
│ │ │ │ │ │ │ └── body: (length: 1) │ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ └── @ BeginNode (location: (141...195)) │ │ │ │ │ │ │ └── @ BeginNode (location: (16,2)-(20,5))
│ │ │ │ │ │ │ ├── begin_keyword_loc: (141...146) = "begin" │ │ │ │ │ │ │ ├── begin_keyword_loc: (16,2)-(16,7) = "begin"
│ │ │ │ │ │ │ ├── statements: │ │ │ │ │ │ │ ├── statements:
│ │ │ │ │ │ │ │ @ StatementsNode (location: (151...156)) │ │ │ │ │ │ │ │ @ StatementsNode (location: (17,4)-(17,9))
│ │ │ │ │ │ │ │ └── body: (length: 1) │ │ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ │ └── @ BreakNode (location: (151...156)) │ │ │ │ │ │ │ │ └── @ BreakNode (location: (17,4)-(17,9))
│ │ │ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ │ │ └── keyword_loc: (151...156) = "break" │ │ │ │ │ │ │ │ └── keyword_loc: (17,4)-(17,9) = "break"
│ │ │ │ │ │ │ ├── rescue_clause: ∅ │ │ │ │ │ │ │ ├── rescue_clause: ∅
│ │ │ │ │ │ │ ├── else_clause: ∅ │ │ │ │ │ │ │ ├── else_clause: ∅
│ │ │ │ │ │ │ ├── ensure_clause: │ │ │ │ │ │ │ ├── ensure_clause:
│ │ │ │ │ │ │ │ @ EnsureNode (location: (161...195)) │ │ │ │ │ │ │ │ @ EnsureNode (location: (18,4)-(20,5))
│ │ │ │ │ │ │ │ ├── ensure_keyword_loc: (161...167) = "ensure" │ │ │ │ │ │ │ │ ├── ensure_keyword_loc: (18,4)-(18,10) = "ensure"
│ │ │ │ │ │ │ │ ├── statements: │ │ │ │ │ │ │ │ ├── statements:
│ │ │ │ │ │ │ │ │ @ StatementsNode (location: (168...189)) │ │ │ │ │ │ │ │ │ @ StatementsNode (location: (18,11)-(19,7))
│ │ │ │ │ │ │ │ │ └── body: (length: 1) │ │ │ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ │ │ └── @ CallNode (location: (168...189)) │ │ │ │ │ │ │ │ │ └── @ CallNode (location: (18,11)-(19,7))
│ │ │ │ │ │ │ │ │ ├── receiver: │ │ │ │ │ │ │ │ │ ├── receiver:
│ │ │ │ │ │ │ │ │ │ @ ConstantReadNode (location: (168...174)) │ │ │ │ │ │ │ │ │ │ @ ConstantReadNode (location: (18,11)-(18,17))
│ │ │ │ │ │ │ │ │ │ └── name: :Module │ │ │ │ │ │ │ │ │ │ └── name: :Module
│ │ │ │ │ │ │ │ │ ├── call_operator_loc: (174...175) = "." │ │ │ │ │ │ │ │ │ ├── call_operator_loc: (18,17)-(18,18) = "."
│ │ │ │ │ │ │ │ │ ├── message_loc: (175...178) = "new" │ │ │ │ │ │ │ │ │ ├── message_loc: (18,18)-(18,21) = "new"
│ │ │ │ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ │ │ │ ├── block: │ │ │ │ │ │ │ │ │ ├── block:
│ │ │ │ │ │ │ │ │ │ @ BlockNode (location: (179...189)) │ │ │ │ │ │ │ │ │ │ @ BlockNode (location: (18,22)-(19,7))
│ │ │ │ │ │ │ │ │ │ ├── locals: [] │ │ │ │ │ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ │ │ │ │ ├── body: ∅ │ │ │ │ │ │ │ │ │ │ ├── body: ∅
│ │ │ │ │ │ │ │ │ │ ├── opening_loc: (179...181) = "do" │ │ │ │ │ │ │ │ │ │ ├── opening_loc: (18,22)-(18,24) = "do"
│ │ │ │ │ │ │ │ │ │ └── closing_loc: (186...189) = "end" │ │ │ │ │ │ │ │ │ │ └── closing_loc: (19,4)-(19,7) = "end"
│ │ │ │ │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ │ │ │ │ └── name: "new" │ │ │ │ │ │ │ │ │ └── name: "new"
│ │ │ │ │ │ │ │ └── end_keyword_loc: (192...195) = "end" │ │ │ │ │ │ │ │ └── end_keyword_loc: (20,2)-(20,5) = "end"
│ │ │ │ │ │ │ └── end_keyword_loc: (192...195) = "end" │ │ │ │ │ │ │ └── end_keyword_loc: (20,2)-(20,5) = "end"
│ │ │ │ │ │ ├── opening_loc: (136...138) = "do" │ │ │ │ │ │ ├── opening_loc: (15,40)-(15,42) = "do"
│ │ │ │ │ │ └── closing_loc: (196...199) = "end" │ │ │ │ │ │ └── closing_loc: (21,0)-(21,3) = "end"
│ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "new" │ │ │ │ │ └── name: "new"
│ │ │ │ └── end_keyword_loc: (200...203) = "end" │ │ │ │ └── end_keyword_loc: (21,4)-(21,7) = "end"
│ │ │ └── end_keyword_loc: (200...203) = "end" │ │ │ └── end_keyword_loc: (21,4)-(21,7) = "end"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
@ -242,8 +242,8 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (204...207) = "end" │ └── end_keyword_loc: (21,8)-(21,11) = "end"
├── rescue_clause: ∅ ├── rescue_clause: ∅
├── else_clause: ∅ ├── else_clause: ∅
├── ensure_clause: ∅ ├── ensure_clause: ∅
└── end_keyword_loc: (208...211) = "end" └── end_keyword_loc: (21,12)-(21,15) = "end"

442
test/yarp/snapshots/begin_rescue.txt
View file

@ -1,17 +1,17 @@
@ ProgramNode (location: (0...578)) @ ProgramNode (location: (1,0)-(78,3))
├── locals: [:ex] ├── locals: [:ex]
└── statements: └── statements:
@ StatementsNode (location: (0...578)) @ StatementsNode (location: (1,0)-(78,3))
└── body: (length: 17) └── body: (length: 17)
├── @ BeginNode (location: (0...33)) ├── @ BeginNode (location: (1,0)-(1,33))
│ ├── begin_keyword_loc: (0...5) = "begin" │ ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (7...8)) │ │ @ StatementsNode (location: (1,7)-(1,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (7...8)) │ │ └── @ CallNode (location: (1,7)-(1,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (7...8) = "a" │ │ ├── message_loc: (1,7)-(1,8) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -19,18 +19,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (10...19)) │ │ @ RescueNode (location: (1,10)-(1,19))
│ │ ├── keyword_loc: (10...16) = "rescue" │ │ ├── keyword_loc: (1,10)-(1,16) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (18...19)) │ │ │ @ StatementsNode (location: (1,18)-(1,19))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (18...19)) │ │ │ └── @ CallNode (location: (1,18)-(1,19))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (18...19) = "b" │ │ │ ├── message_loc: (1,18)-(1,19) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -39,33 +39,33 @@
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: │ ├── else_clause:
│ │ @ ElseNode (location: (21...33)) │ │ @ ElseNode (location: (1,21)-(1,33))
│ │ ├── else_keyword_loc: (21...25) = "else" │ │ ├── else_keyword_loc: (1,21)-(1,25) = "else"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (27...28)) │ │ │ @ StatementsNode (location: (1,27)-(1,28))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (27...28)) │ │ │ └── @ CallNode (location: (1,27)-(1,28))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (27...28) = "c" │ │ │ ├── message_loc: (1,27)-(1,28) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "c" │ │ │ └── name: "c"
│ │ └── end_keyword_loc: (30...33) = "end" │ │ └── end_keyword_loc: (1,30)-(1,33) = "end"
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (30...33) = "end" │ └── end_keyword_loc: (1,30)-(1,33) = "end"
├── @ BeginNode (location: (35...79)) ├── @ BeginNode (location: (3,0)-(3,44))
│ ├── begin_keyword_loc: (35...40) = "begin" │ ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (42...43)) │ │ @ StatementsNode (location: (3,7)-(3,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (42...43)) │ │ └── @ CallNode (location: (3,7)-(3,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (42...43) = "a" │ │ ├── message_loc: (3,7)-(3,8) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -73,18 +73,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (45...54)) │ │ @ RescueNode (location: (3,10)-(3,19))
│ │ ├── keyword_loc: (45...51) = "rescue" │ │ ├── keyword_loc: (3,10)-(3,16) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (53...54)) │ │ │ @ StatementsNode (location: (3,18)-(3,19))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (53...54)) │ │ │ └── @ CallNode (location: (3,18)-(3,19))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (53...54) = "b" │ │ │ ├── message_loc: (3,18)-(3,19) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -93,49 +93,49 @@
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: │ ├── else_clause:
│ │ @ ElseNode (location: (56...71)) │ │ @ ElseNode (location: (3,21)-(3,36))
│ │ ├── else_keyword_loc: (56...60) = "else" │ │ ├── else_keyword_loc: (3,21)-(3,25) = "else"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (62...63)) │ │ │ @ StatementsNode (location: (3,27)-(3,28))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (62...63)) │ │ │ └── @ CallNode (location: (3,27)-(3,28))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (62...63) = "c" │ │ │ ├── message_loc: (3,27)-(3,28) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "c" │ │ │ └── name: "c"
│ │ └── end_keyword_loc: (65...71) = "ensure" │ │ └── end_keyword_loc: (3,30)-(3,36) = "ensure"
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (65...79)) │ │ @ EnsureNode (location: (3,30)-(3,44))
│ │ ├── ensure_keyword_loc: (65...71) = "ensure" │ │ ├── ensure_keyword_loc: (3,30)-(3,36) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (73...74)) │ │ │ @ StatementsNode (location: (3,38)-(3,39))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (73...74)) │ │ │ └── @ CallNode (location: (3,38)-(3,39))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (73...74) = "d" │ │ │ ├── message_loc: (3,38)-(3,39) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ └── end_keyword_loc: (76...79) = "end" │ │ └── end_keyword_loc: (3,41)-(3,44) = "end"
│ └── end_keyword_loc: (76...79) = "end" │ └── end_keyword_loc: (3,41)-(3,44) = "end"
├── @ BeginNode (location: (81...92)) ├── @ BeginNode (location: (5,0)-(7,3))
│ ├── begin_keyword_loc: (81...86) = "begin" │ ├── begin_keyword_loc: (5,0)-(5,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (87...88)) │ │ @ StatementsNode (location: (6,0)-(6,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (87...88)) │ │ └── @ CallNode (location: (6,0)-(6,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (87...88) = "a" │ │ ├── message_loc: (6,0)-(6,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -145,16 +145,16 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (89...92) = "end" │ └── end_keyword_loc: (7,0)-(7,3) = "end"
├── @ BeginNode (location: (94...107)) ├── @ BeginNode (location: (9,0)-(9,13))
│ ├── begin_keyword_loc: (94...99) = "begin" │ ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (101...102)) │ │ @ StatementsNode (location: (9,7)-(9,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (101...102)) │ │ └── @ CallNode (location: (9,7)-(9,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (101...102) = "a" │ │ ├── message_loc: (9,7)-(9,8) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -164,16 +164,16 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (104...107) = "end" │ └── end_keyword_loc: (9,10)-(9,13) = "end"
├── @ BeginNode (location: (109...121)) ├── @ BeginNode (location: (11,0)-(12,4))
│ ├── begin_keyword_loc: (109...114) = "begin" │ ├── begin_keyword_loc: (11,0)-(11,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (115...116)) │ │ @ StatementsNode (location: (11,6)-(11,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (115...116)) │ │ └── @ CallNode (location: (11,6)-(11,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (115...116) = "a" │ │ ├── message_loc: (11,6)-(11,7) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -183,16 +183,16 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (118...121) = "end" │ └── end_keyword_loc: (12,1)-(12,4) = "end"
├── @ BeginNode (location: (123...135)) ├── @ BeginNode (location: (14,0)-(14,12))
│ ├── begin_keyword_loc: (123...128) = "begin" │ ├── begin_keyword_loc: (14,0)-(14,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (129...130)) │ │ @ StatementsNode (location: (14,6)-(14,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (129...130)) │ │ └── @ CallNode (location: (14,6)-(14,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (129...130) = "a" │ │ ├── message_loc: (14,6)-(14,7) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -202,16 +202,16 @@
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (132...135) = "end" │ └── end_keyword_loc: (14,9)-(14,12) = "end"
├── @ BeginNode (location: (137...175)) ├── @ BeginNode (location: (16,0)-(24,3))
│ ├── begin_keyword_loc: (137...142) = "begin" │ ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (143...144)) │ │ @ StatementsNode (location: (17,0)-(17,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (143...144)) │ │ └── @ CallNode (location: (17,0)-(17,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (143...144) = "a" │ │ ├── message_loc: (17,0)-(17,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -219,18 +219,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (145...171)) │ │ @ RescueNode (location: (18,0)-(23,1))
│ │ ├── keyword_loc: (145...151) = "rescue" │ │ ├── keyword_loc: (18,0)-(18,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (152...153)) │ │ │ @ StatementsNode (location: (19,0)-(19,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (152...153)) │ │ │ └── @ CallNode (location: (19,0)-(19,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (152...153) = "b" │ │ │ ├── message_loc: (19,0)-(19,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -238,18 +238,18 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── consequent: │ │ └── consequent:
│ │ @ RescueNode (location: (154...171)) │ │ @ RescueNode (location: (20,0)-(23,1))
│ │ ├── keyword_loc: (154...160) = "rescue" │ │ ├── keyword_loc: (20,0)-(20,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (161...162)) │ │ │ @ StatementsNode (location: (21,0)-(21,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (161...162)) │ │ │ └── @ CallNode (location: (21,0)-(21,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (161...162) = "c" │ │ │ ├── message_loc: (21,0)-(21,1) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -257,18 +257,18 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "c" │ │ │ └── name: "c"
│ │ └── consequent: │ │ └── consequent:
│ │ @ RescueNode (location: (163...171)) │ │ @ RescueNode (location: (22,0)-(23,1))
│ │ ├── keyword_loc: (163...169) = "rescue" │ │ ├── keyword_loc: (22,0)-(22,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (170...171)) │ │ │ @ StatementsNode (location: (23,0)-(23,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (170...171)) │ │ │ └── @ CallNode (location: (23,0)-(23,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (170...171) = "d" │ │ │ ├── message_loc: (23,0)-(23,1) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -278,16 +278,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (172...175) = "end" │ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ BeginNode (location: (177...269)) ├── @ BeginNode (location: (26,0)-(32,3))
│ ├── begin_keyword_loc: (177...182) = "begin" │ ├── begin_keyword_loc: (26,0)-(26,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (185...186)) │ │ @ StatementsNode (location: (27,2)-(27,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (185...186)) │ │ └── @ CallNode (location: (27,2)-(27,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (185...186) = "a" │ │ ├── message_loc: (27,2)-(27,3) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -295,23 +295,23 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (187...265)) │ │ @ RescueNode (location: (28,0)-(31,3))
│ │ ├── keyword_loc: (187...193) = "rescue" │ │ ├── keyword_loc: (28,0)-(28,6) = "rescue"
│ │ ├── exceptions: (length: 1) │ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (194...203)) │ │ │ └── @ ConstantReadNode (location: (28,7)-(28,16))
│ │ │ └── name: :Exception │ │ │ └── name: :Exception
│ │ ├── operator_loc: (204...206) = "=>" │ │ ├── operator_loc: (28,17)-(28,19) = "=>"
│ │ ├── reference: │ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (207...209)) │ │ │ @ LocalVariableTargetNode (location: (28,20)-(28,22))
│ │ │ ├── name: :ex │ │ │ ├── name: :ex
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (212...213)) │ │ │ @ StatementsNode (location: (29,2)-(29,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (212...213)) │ │ │ └── @ CallNode (location: (29,2)-(29,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (212...213) = "b" │ │ │ ├── message_loc: (29,2)-(29,3) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -319,25 +319,25 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── consequent: │ │ └── consequent:
│ │ @ RescueNode (location: (214...265)) │ │ @ RescueNode (location: (30,0)-(31,3))
│ │ ├── keyword_loc: (214...220) = "rescue" │ │ ├── keyword_loc: (30,0)-(30,6) = "rescue"
│ │ ├── exceptions: (length: 2) │ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (221...237)) │ │ │ ├── @ ConstantReadNode (location: (30,7)-(30,23))
│ │ │ │ └── name: :AnotherException │ │ │ │ └── name: :AnotherException
│ │ │ └── @ ConstantReadNode (location: (239...255)) │ │ │ └── @ ConstantReadNode (location: (30,25)-(30,41))
│ │ │ └── name: :OneMoreException │ │ │ └── name: :OneMoreException
│ │ ├── operator_loc: (256...258) = "=>" │ │ ├── operator_loc: (30,42)-(30,44) = "=>"
│ │ ├── reference: │ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (259...261)) │ │ │ @ LocalVariableTargetNode (location: (30,45)-(30,47))
│ │ │ ├── name: :ex │ │ │ ├── name: :ex
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (264...265)) │ │ │ @ StatementsNode (location: (31,2)-(31,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (264...265)) │ │ │ └── @ CallNode (location: (31,2)-(31,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (264...265) = "c" │ │ │ ├── message_loc: (31,2)-(31,3) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -347,16 +347,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (266...269) = "end" │ └── end_keyword_loc: (32,0)-(32,3) = "end"
├── @ BeginNode (location: (271...322)) ├── @ BeginNode (location: (34,0)-(40,3))
│ ├── begin_keyword_loc: (271...276) = "begin" │ ├── begin_keyword_loc: (34,0)-(34,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (279...280)) │ │ @ StatementsNode (location: (35,2)-(35,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (279...280)) │ │ └── @ CallNode (location: (35,2)-(35,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (279...280) = "a" │ │ ├── message_loc: (35,2)-(35,3) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -364,23 +364,23 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (281...307)) │ │ @ RescueNode (location: (36,0)-(37,3))
│ │ ├── keyword_loc: (281...287) = "rescue" │ │ ├── keyword_loc: (36,0)-(36,6) = "rescue"
│ │ ├── exceptions: (length: 1) │ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (288...297)) │ │ │ └── @ ConstantReadNode (location: (36,7)-(36,16))
│ │ │ └── name: :Exception │ │ │ └── name: :Exception
│ │ ├── operator_loc: (298...300) = "=>" │ │ ├── operator_loc: (36,17)-(36,19) = "=>"
│ │ ├── reference: │ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (301...303)) │ │ │ @ LocalVariableTargetNode (location: (36,20)-(36,22))
│ │ │ ├── name: :ex │ │ │ ├── name: :ex
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (306...307)) │ │ │ @ StatementsNode (location: (37,2)-(37,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (306...307)) │ │ │ └── @ CallNode (location: (37,2)-(37,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (306...307) = "b" │ │ │ ├── message_loc: (37,2)-(37,3) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -390,38 +390,38 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (308...322)) │ │ @ EnsureNode (location: (38,0)-(40,3))
│ │ ├── ensure_keyword_loc: (308...314) = "ensure" │ │ ├── ensure_keyword_loc: (38,0)-(38,6) = "ensure"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (317...318)) │ │ │ @ StatementsNode (location: (39,2)-(39,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (317...318)) │ │ │ └── @ CallNode (location: (39,2)-(39,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (317...318) = "b" │ │ │ ├── message_loc: (39,2)-(39,3) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ └── end_keyword_loc: (319...322) = "end" │ │ └── end_keyword_loc: (40,0)-(40,3) = "end"
│ └── end_keyword_loc: (319...322) = "end" │ └── end_keyword_loc: (40,0)-(40,3) = "end"
├── @ StringNode (location: (324...330)) ├── @ StringNode (location: (42,0)-(42,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (324...326) = "%!" │ ├── opening_loc: (42,0)-(42,2) = "%!"
│ ├── content_loc: (326...329) = "abc" │ ├── content_loc: (42,2)-(42,5) = "abc"
│ ├── closing_loc: (329...330) = "!" │ ├── closing_loc: (42,5)-(42,6) = "!"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ BeginNode (location: (332...352)) ├── @ BeginNode (location: (44,0)-(48,3))
│ ├── begin_keyword_loc: (332...337) = "begin" │ ├── begin_keyword_loc: (44,0)-(44,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (338...339)) │ │ @ StatementsNode (location: (45,0)-(45,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (338...339)) │ │ └── @ CallNode (location: (45,0)-(45,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (338...339) = "a" │ │ ├── message_loc: (45,0)-(45,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -429,18 +429,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (340...348)) │ │ @ RescueNode (location: (46,0)-(47,1))
│ │ ├── keyword_loc: (340...346) = "rescue" │ │ ├── keyword_loc: (46,0)-(46,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (347...348)) │ │ │ @ StatementsNode (location: (47,0)-(47,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (347...348)) │ │ │ └── @ CallNode (location: (47,0)-(47,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (347...348) = "b" │ │ │ ├── message_loc: (47,0)-(47,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -450,16 +450,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (349...352) = "end" │ └── end_keyword_loc: (48,0)-(48,3) = "end"
├── @ BeginNode (location: (354...374)) ├── @ BeginNode (location: (50,0)-(50,20))
│ ├── begin_keyword_loc: (354...359) = "begin" │ ├── begin_keyword_loc: (50,0)-(50,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (360...361)) │ │ @ StatementsNode (location: (50,6)-(50,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (360...361)) │ │ └── @ CallNode (location: (50,6)-(50,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (360...361) = "a" │ │ ├── message_loc: (50,6)-(50,7) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -467,18 +467,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (362...370)) │ │ @ RescueNode (location: (50,8)-(50,16))
│ │ ├── keyword_loc: (362...368) = "rescue" │ │ ├── keyword_loc: (50,8)-(50,14) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (369...370)) │ │ │ @ StatementsNode (location: (50,15)-(50,16))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (369...370)) │ │ │ └── @ CallNode (location: (50,15)-(50,16))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (369...370) = "b" │ │ │ ├── message_loc: (50,15)-(50,16) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -488,16 +488,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (371...374) = "end" │ └── end_keyword_loc: (50,17)-(50,20) = "end"
├── @ BeginNode (location: (376...396)) ├── @ BeginNode (location: (52,0)-(54,5))
│ ├── begin_keyword_loc: (376...381) = "begin" │ ├── begin_keyword_loc: (52,0)-(52,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (382...383)) │ │ @ StatementsNode (location: (53,0)-(53,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (382...383)) │ │ └── @ CallNode (location: (53,0)-(53,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (382...383) = "a" │ │ ├── message_loc: (53,0)-(53,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -505,18 +505,18 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (384...392)) │ │ @ RescueNode (location: (53,2)-(54,1))
│ │ ├── keyword_loc: (384...390) = "rescue" │ │ ├── keyword_loc: (53,2)-(53,8) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (391...392)) │ │ │ @ StatementsNode (location: (54,0)-(54,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (391...392)) │ │ │ └── @ CallNode (location: (54,0)-(54,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (391...392) = "b" │ │ │ ├── message_loc: (54,0)-(54,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -526,16 +526,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (393...396) = "end" │ └── end_keyword_loc: (54,2)-(54,5) = "end"
├── @ BeginNode (location: (398...428)) ├── @ BeginNode (location: (56,0)-(60,3))
│ ├── begin_keyword_loc: (398...403) = "begin" │ ├── begin_keyword_loc: (56,0)-(56,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (404...405)) │ │ @ StatementsNode (location: (57,0)-(57,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (404...405)) │ │ └── @ CallNode (location: (57,0)-(57,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (404...405) = "a" │ │ ├── message_loc: (57,0)-(57,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -543,20 +543,20 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (406...424)) │ │ @ RescueNode (location: (58,0)-(59,1))
│ │ ├── keyword_loc: (406...412) = "rescue" │ │ ├── keyword_loc: (58,0)-(58,6) = "rescue"
│ │ ├── exceptions: (length: 1) │ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (413...422)) │ │ │ └── @ ConstantReadNode (location: (58,7)-(58,16))
│ │ │ └── name: :Exception │ │ │ └── name: :Exception
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (423...424)) │ │ │ @ StatementsNode (location: (59,0)-(59,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (423...424)) │ │ │ └── @ CallNode (location: (59,0)-(59,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (423...424) = "b" │ │ │ ├── message_loc: (59,0)-(59,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -566,16 +566,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (425...428) = "end" │ └── end_keyword_loc: (60,0)-(60,3) = "end"
├── @ BeginNode (location: (430...477)) ├── @ BeginNode (location: (62,0)-(66,3))
│ ├── begin_keyword_loc: (430...435) = "begin" │ ├── begin_keyword_loc: (62,0)-(62,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (436...437)) │ │ @ StatementsNode (location: (63,0)-(63,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (436...437)) │ │ └── @ CallNode (location: (63,0)-(63,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (436...437) = "a" │ │ ├── message_loc: (63,0)-(63,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -583,22 +583,22 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (438...473)) │ │ @ RescueNode (location: (64,0)-(65,1))
│ │ ├── keyword_loc: (438...444) = "rescue" │ │ ├── keyword_loc: (64,0)-(64,6) = "rescue"
│ │ ├── exceptions: (length: 2) │ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (445...454)) │ │ │ ├── @ ConstantReadNode (location: (64,7)-(64,16))
│ │ │ │ └── name: :Exception │ │ │ │ └── name: :Exception
│ │ │ └── @ ConstantReadNode (location: (456...471)) │ │ │ └── @ ConstantReadNode (location: (64,18)-(64,33))
│ │ │ └── name: :CustomException │ │ │ └── name: :CustomException
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (472...473)) │ │ │ @ StatementsNode (location: (65,0)-(65,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (472...473)) │ │ │ └── @ CallNode (location: (65,0)-(65,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (472...473) = "b" │ │ │ ├── message_loc: (65,0)-(65,1) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -608,16 +608,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (474...477) = "end" │ └── end_keyword_loc: (66,0)-(66,3) = "end"
├── @ BeginNode (location: (479...536)) ├── @ BeginNode (location: (68,0)-(72,3))
│ ├── begin_keyword_loc: (479...484) = "begin" │ ├── begin_keyword_loc: (68,0)-(68,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (487...488)) │ │ @ StatementsNode (location: (69,2)-(69,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (487...488)) │ │ └── @ CallNode (location: (69,2)-(69,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (487...488) = "a" │ │ ├── message_loc: (69,2)-(69,3) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -625,25 +625,25 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (489...532)) │ │ @ RescueNode (location: (70,0)-(71,3))
│ │ ├── keyword_loc: (489...495) = "rescue" │ │ ├── keyword_loc: (70,0)-(70,6) = "rescue"
│ │ ├── exceptions: (length: 2) │ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (496...505)) │ │ │ ├── @ ConstantReadNode (location: (70,7)-(70,16))
│ │ │ │ └── name: :Exception │ │ │ │ └── name: :Exception
│ │ │ └── @ ConstantReadNode (location: (507...522)) │ │ │ └── @ ConstantReadNode (location: (70,18)-(70,33))
│ │ │ └── name: :CustomException │ │ │ └── name: :CustomException
│ │ ├── operator_loc: (523...525) = "=>" │ │ ├── operator_loc: (70,34)-(70,36) = "=>"
│ │ ├── reference: │ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (526...528)) │ │ │ @ LocalVariableTargetNode (location: (70,37)-(70,39))
│ │ │ ├── name: :ex │ │ │ ├── name: :ex
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (531...532)) │ │ │ @ StatementsNode (location: (71,2)-(71,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (531...532)) │ │ │ └── @ CallNode (location: (71,2)-(71,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (531...532) = "b" │ │ │ ├── message_loc: (71,2)-(71,3) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -653,16 +653,16 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (533...536) = "end" │ └── end_keyword_loc: (72,0)-(72,3) = "end"
└── @ BeginNode (location: (538...578)) └── @ BeginNode (location: (74,0)-(78,3))
├── begin_keyword_loc: (538...543) = "begin" ├── begin_keyword_loc: (74,0)-(74,5) = "begin"
├── statements: ├── statements:
│ @ StatementsNode (location: (546...547)) │ @ StatementsNode (location: (75,2)-(75,3))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (546...547)) │ └── @ CallNode (location: (75,2)-(75,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (546...547) = "a" │ ├── message_loc: (75,2)-(75,3) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
@ -670,23 +670,23 @@
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "a" │ └── name: "a"
├── rescue_clause: ├── rescue_clause:
│ @ RescueNode (location: (548...574)) │ @ RescueNode (location: (76,0)-(77,3))
│ ├── keyword_loc: (548...554) = "rescue" │ ├── keyword_loc: (76,0)-(76,6) = "rescue"
│ ├── exceptions: (length: 1) │ ├── exceptions: (length: 1)
│ │ └── @ ConstantReadNode (location: (555...564)) │ │ └── @ ConstantReadNode (location: (76,7)-(76,16))
│ │ └── name: :Exception │ │ └── name: :Exception
│ ├── operator_loc: (565...567) = "=>" │ ├── operator_loc: (76,17)-(76,19) = "=>"
│ ├── reference: │ ├── reference:
│ │ @ LocalVariableTargetNode (location: (568...570)) │ │ @ LocalVariableTargetNode (location: (76,20)-(76,22))
│ │ ├── name: :ex │ │ ├── name: :ex
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (573...574)) │ │ @ StatementsNode (location: (77,2)-(77,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (573...574)) │ │ └── @ CallNode (location: (77,2)-(77,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (573...574) = "b" │ │ ├── message_loc: (77,2)-(77,3) = "b"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -696,4 +696,4 @@
│ └── consequent: ∅ │ └── consequent: ∅
├── else_clause: ∅ ├── else_clause: ∅
├── ensure_clause: ∅ ├── ensure_clause: ∅
└── end_keyword_loc: (575...578) = "end" └── end_keyword_loc: (78,0)-(78,3) = "end"

492
test/yarp/snapshots/blocks.txt
View file

@ -1,14 +1,14 @@
@ ProgramNode (location: (0...402)) @ ProgramNode (location: (1,0)-(54,17))
├── locals: [:fork] ├── locals: [:fork]
└── statements: └── statements:
@ StatementsNode (location: (0...402)) @ StatementsNode (location: (1,0)-(54,17))
└── body: (length: 20) └── body: (length: 20)
├── @ CallNode (location: (0...16)) ├── @ CallNode (location: (1,0)-(1,16))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (0...3)) │ │ @ CallNode (location: (1,0)-(1,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "foo" │ │ ├── message_loc: (1,0)-(1,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -16,49 +16,49 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (3...8) = "[bar]" │ ├── message_loc: (1,3)-(1,8) = "[bar]"
│ ├── opening_loc: (3...4) = "[" │ ├── opening_loc: (1,3)-(1,4) = "["
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7)) │ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7)) │ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...7) = "bar" │ │ ├── message_loc: (1,4)-(1,7) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── closing_loc: (7...8) = "]" │ ├── closing_loc: (1,7)-(1,8) = "]"
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (9...16)) │ │ @ BlockNode (location: (1,9)-(1,16))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (11...14)) │ │ │ @ StatementsNode (location: (1,11)-(1,14))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...14)) │ │ │ └── @ CallNode (location: (1,11)-(1,14))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...14) = "baz" │ │ │ ├── message_loc: (1,11)-(1,14) = "baz"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "baz" │ │ │ └── name: "baz"
│ │ ├── opening_loc: (9...10) = "{" │ │ ├── opening_loc: (1,9)-(1,10) = "{"
│ │ └── closing_loc: (15...16) = "}" │ │ └── closing_loc: (1,15)-(1,16) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "[]" │ └── name: "[]"
├── @ CallNode (location: (18...37)) ├── @ CallNode (location: (3,0)-(5,3))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (18...21)) │ │ @ CallNode (location: (3,0)-(3,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (18...21) = "foo" │ │ ├── message_loc: (3,0)-(3,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -66,75 +66,75 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (21...26) = "[bar]" │ ├── message_loc: (3,3)-(3,8) = "[bar]"
│ ├── opening_loc: (21...22) = "[" │ ├── opening_loc: (3,3)-(3,4) = "["
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (22...25)) │ │ @ ArgumentsNode (location: (3,4)-(3,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (22...25)) │ │ └── @ CallNode (location: (3,4)-(3,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (22...25) = "bar" │ │ ├── message_loc: (3,4)-(3,7) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── closing_loc: (25...26) = "]" │ ├── closing_loc: (3,7)-(3,8) = "]"
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (27...37)) │ │ @ BlockNode (location: (3,9)-(5,3))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (30...33)) │ │ │ @ StatementsNode (location: (4,0)-(4,3))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (30...33)) │ │ │ └── @ CallNode (location: (4,0)-(4,3))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (30...33) = "baz" │ │ │ ├── message_loc: (4,0)-(4,3) = "baz"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "baz" │ │ │ └── name: "baz"
│ │ ├── opening_loc: (27...29) = "do" │ │ ├── opening_loc: (3,9)-(3,11) = "do"
│ │ └── closing_loc: (34...37) = "end" │ │ └── closing_loc: (5,0)-(5,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "[]" │ └── name: "[]"
├── @ CallNode (location: (39...74)) ├── @ CallNode (location: (7,0)-(7,35))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (39...40)) │ │ @ CallNode (location: (7,0)-(7,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (39...40) = "x" │ │ ├── message_loc: (7,0)-(7,1) = "x"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "x" │ │ └── name: "x"
│ ├── call_operator_loc: (40...41) = "." │ ├── call_operator_loc: (7,1)-(7,2) = "."
│ ├── message_loc: (41...47) = "reduce" │ ├── message_loc: (7,2)-(7,8) = "reduce"
│ ├── opening_loc: (47...48) = "(" │ ├── opening_loc: (7,8)-(7,9) = "("
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (48...49)) │ │ @ ArgumentsNode (location: (7,9)-(7,10))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (48...49)) │ │ └── @ IntegerNode (location: (7,9)-(7,10))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: (49...50) = ")" │ ├── closing_loc: (7,10)-(7,11) = ")"
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (51...74)) │ │ @ BlockNode (location: (7,12)-(7,35))
│ │ ├── locals: [:x, :memo] │ │ ├── locals: [:x, :memo]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (53...62)) │ │ │ @ BlockParametersNode (location: (7,14)-(7,23))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (54...61)) │ │ │ │ @ ParametersNode (location: (7,15)-(7,22))
│ │ │ │ ├── requireds: (length: 2) │ │ │ │ ├── requireds: (length: 2)
│ │ │ │ │ ├── @ RequiredParameterNode (location: (54...55)) │ │ │ │ │ ├── @ RequiredParameterNode (location: (7,15)-(7,16))
│ │ │ │ │ │ └── name: :x │ │ │ │ │ │ └── name: :x
│ │ │ │ │ └── @ RequiredParameterNode (location: (57...61)) │ │ │ │ │ └── @ RequiredParameterNode (location: (7,18)-(7,22))
│ │ │ │ │ └── name: :memo │ │ │ │ │ └── name: :memo
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -143,97 +143,97 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (53...54) = "|" │ │ │ ├── opening_loc: (7,14)-(7,15) = "|"
│ │ │ └── closing_loc: (61...62) = "|" │ │ │ └── closing_loc: (7,22)-(7,23) = "|"
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (63...72)) │ │ │ @ StatementsNode (location: (7,24)-(7,33))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableOperatorWriteNode (location: (63...72)) │ │ │ └── @ LocalVariableOperatorWriteNode (location: (7,24)-(7,33))
│ │ │ ├── name_loc: (63...67) = "memo" │ │ │ ├── name_loc: (7,24)-(7,28) = "memo"
│ │ │ ├── operator_loc: (68...70) = "+=" │ │ │ ├── operator_loc: (7,29)-(7,31) = "+="
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ LocalVariableReadNode (location: (71...72)) │ │ │ │ @ LocalVariableReadNode (location: (7,32)-(7,33))
│ │ │ │ ├── name: :x │ │ │ │ ├── name: :x
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── name: :memo │ │ │ ├── name: :memo
│ │ │ ├── operator: :+ │ │ │ ├── operator: :+
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── opening_loc: (51...52) = "{" │ │ ├── opening_loc: (7,12)-(7,13) = "{"
│ │ └── closing_loc: (73...74) = "}" │ │ └── closing_loc: (7,34)-(7,35) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "reduce" │ └── name: "reduce"
├── @ CallNode (location: (76...86)) ├── @ CallNode (location: (9,0)-(9,10))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (76...79) = "foo" │ ├── message_loc: (9,0)-(9,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (80...86)) │ │ @ BlockNode (location: (9,4)-(9,10))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (80...82) = "do" │ │ ├── opening_loc: (9,4)-(9,6) = "do"
│ │ └── closing_loc: (83...86) = "end" │ │ └── closing_loc: (9,7)-(9,10) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (88...109)) ├── @ CallNode (location: (11,0)-(11,21))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (88...91) = "foo" │ ├── message_loc: (11,0)-(11,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (92...109)) │ │ @ ArgumentsNode (location: (11,4)-(11,21))
│ │ └── arguments: (length: 2) │ │ └── arguments: (length: 2)
│ │ ├── @ CallNode (location: (92...95)) │ │ ├── @ CallNode (location: (11,4)-(11,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (92...95) = "bar" │ │ │ ├── message_loc: (11,4)-(11,7) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ └── @ ParenthesesNode (location: (97...109)) │ │ └── @ ParenthesesNode (location: (11,9)-(11,21))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (98...108)) │ │ │ @ StatementsNode (location: (11,10)-(11,20))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (98...108)) │ │ │ └── @ CallNode (location: (11,10)-(11,20))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (98...101) = "baz" │ │ │ ├── message_loc: (11,10)-(11,13) = "baz"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: │ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (102...108)) │ │ │ │ @ BlockNode (location: (11,14)-(11,20))
│ │ │ │ ├── locals: [] │ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅ │ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body: ∅ │ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (102...104) = "do" │ │ │ │ ├── opening_loc: (11,14)-(11,16) = "do"
│ │ │ │ └── closing_loc: (105...108) = "end" │ │ │ │ └── closing_loc: (11,17)-(11,20) = "end"
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "baz" │ │ │ └── name: "baz"
│ │ ├── opening_loc: (97...98) = "(" │ │ ├── opening_loc: (11,9)-(11,10) = "("
│ │ └── closing_loc: (108...109) = ")" │ │ └── closing_loc: (11,20)-(11,21) = ")"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (111...125)) ├── @ CallNode (location: (13,0)-(13,14))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (111...114) = "foo" │ ├── message_loc: (13,0)-(13,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (115...118)) │ │ @ ArgumentsNode (location: (13,4)-(13,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (115...118)) │ │ └── @ CallNode (location: (13,4)-(13,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (115...118) = "bar" │ │ ├── message_loc: (13,4)-(13,7) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -242,34 +242,34 @@
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (119...125)) │ │ @ BlockNode (location: (13,8)-(13,14))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (119...121) = "do" │ │ ├── opening_loc: (13,8)-(13,10) = "do"
│ │ └── closing_loc: (122...125) = "end" │ │ └── closing_loc: (13,11)-(13,14) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (127...145)) ├── @ CallNode (location: (15,0)-(15,18))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (127...130) = "foo" │ ├── message_loc: (15,0)-(15,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (131...138)) │ │ @ ArgumentsNode (location: (15,4)-(15,11))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (131...138)) │ │ └── @ CallNode (location: (15,4)-(15,11))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (131...134) = "bar" │ │ ├── message_loc: (15,4)-(15,7) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (135...138)) │ │ │ @ ArgumentsNode (location: (15,8)-(15,11))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ CallNode (location: (135...138)) │ │ │ └── @ CallNode (location: (15,8)-(15,11))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (135...138) = "baz" │ │ │ ├── message_loc: (15,8)-(15,11) = "baz"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -282,41 +282,41 @@
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (139...145)) │ │ @ BlockNode (location: (15,12)-(15,18))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (139...141) = "do" │ │ ├── opening_loc: (15,12)-(15,14) = "do"
│ │ └── closing_loc: (142...145) = "end" │ │ └── closing_loc: (15,15)-(15,18) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (147...168)) ├── @ CallNode (location: (17,0)-(18,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (147...150) = "foo" │ ├── message_loc: (17,0)-(17,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (151...168)) │ │ @ BlockNode (location: (17,4)-(18,3))
│ │ ├── locals: [:a] │ │ ├── locals: [:a]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (154...164)) │ │ │ @ BlockParametersNode (location: (17,7)-(17,17))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (155...163)) │ │ │ │ @ ParametersNode (location: (17,8)-(17,16))
│ │ │ │ ├── requireds: (length: 0) │ │ │ │ ├── requireds: (length: 0)
│ │ │ │ ├── optionals: (length: 1) │ │ │ │ ├── optionals: (length: 1)
│ │ │ │ │ └── @ OptionalParameterNode (location: (155...163)) │ │ │ │ │ └── @ OptionalParameterNode (location: (17,8)-(17,16))
│ │ │ │ │ ├── name: :a │ │ │ │ │ ├── name: :a
│ │ │ │ │ ├── name_loc: (155...156) = "a" │ │ │ │ │ ├── name_loc: (17,8)-(17,9) = "a"
│ │ │ │ │ ├── operator_loc: (157...158) = "=" │ │ │ │ │ ├── operator_loc: (17,10)-(17,11) = "="
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ CallNode (location: (159...163)) │ │ │ │ │ @ CallNode (location: (17,12)-(17,16))
│ │ │ │ │ ├── receiver: │ │ │ │ │ ├── receiver:
│ │ │ │ │ │ @ CallNode (location: (159...160)) │ │ │ │ │ │ @ CallNode (location: (17,12)-(17,13))
│ │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ │ ├── message_loc: (159...160) = "b" │ │ │ │ │ │ ├── message_loc: (17,12)-(17,13) = "b"
│ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ ├── closing_loc: ∅
@ -324,14 +324,14 @@
│ │ │ │ │ │ ├── flags: variable_call │ │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ │ └── name: "b" │ │ │ │ │ │ └── name: "b"
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (160...163) = "[1]" │ │ │ │ │ ├── message_loc: (17,13)-(17,16) = "[1]"
│ │ │ │ │ ├── opening_loc: (160...161) = "[" │ │ │ │ │ ├── opening_loc: (17,13)-(17,14) = "["
│ │ │ │ │ ├── arguments: │ │ │ │ │ ├── arguments:
│ │ │ │ │ │ @ ArgumentsNode (location: (161...162)) │ │ │ │ │ │ @ ArgumentsNode (location: (17,14)-(17,15))
│ │ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ │ └── @ IntegerNode (location: (161...162)) │ │ │ │ │ │ └── @ IntegerNode (location: (17,14)-(17,15))
│ │ │ │ │ │ └── flags: decimal │ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ ├── closing_loc: (162...163) = "]" │ │ │ │ │ ├── closing_loc: (17,15)-(17,16) = "]"
│ │ │ │ │ ├── block: ∅ │ │ │ │ │ ├── block: ∅
│ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "[]" │ │ │ │ │ └── name: "[]"
@ -341,31 +341,31 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (154...155) = "|" │ │ │ ├── opening_loc: (17,7)-(17,8) = "|"
│ │ │ └── closing_loc: (163...164) = "|" │ │ │ └── closing_loc: (17,16)-(17,17) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (151...153) = "do" │ │ ├── opening_loc: (17,4)-(17,6) = "do"
│ │ └── closing_loc: (165...168) = "end" │ │ └── closing_loc: (18,0)-(18,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (170...187)) ├── @ CallNode (location: (20,0)-(22,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (170...173) = "foo" │ ├── message_loc: (20,0)-(20,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (174...187)) │ │ @ BlockNode (location: (20,4)-(22,3))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ BeginNode (location: (177...187)) │ │ │ @ BeginNode (location: (21,0)-(22,3))
│ │ │ ├── begin_keyword_loc: ∅ │ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: │ │ │ ├── rescue_clause:
│ │ │ │ @ RescueNode (location: (177...183)) │ │ │ │ @ RescueNode (location: (21,0)-(21,6))
│ │ │ │ ├── keyword_loc: (177...183) = "rescue" │ │ │ │ ├── keyword_loc: (21,0)-(21,6) = "rescue"
│ │ │ │ ├── exceptions: (length: 0) │ │ │ │ ├── exceptions: (length: 0)
│ │ │ │ ├── operator_loc: ∅ │ │ │ │ ├── operator_loc: ∅
│ │ │ │ ├── reference: ∅ │ │ │ │ ├── reference: ∅
@ -373,69 +373,69 @@
│ │ │ │ └── consequent: ∅ │ │ │ │ └── consequent: ∅
│ │ │ ├── else_clause: ∅ │ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause: ∅ │ │ │ ├── ensure_clause: ∅
│ │ │ └── end_keyword_loc: (184...187) = "end" │ │ │ └── end_keyword_loc: (22,0)-(22,3) = "end"
│ │ ├── opening_loc: (174...176) = "do" │ │ ├── opening_loc: (20,4)-(20,6) = "do"
│ │ └── closing_loc: (184...187) = "end" │ │ └── closing_loc: (22,0)-(22,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (189...233)) ├── @ CallNode (location: (24,0)-(29,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (189...192) = "foo" │ ├── message_loc: (24,0)-(24,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (193...233)) │ │ @ BlockNode (location: (24,4)-(29,3))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (198...229)) │ │ │ @ StatementsNode (location: (25,2)-(28,5))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (198...229)) │ │ │ └── @ CallNode (location: (25,2)-(28,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (198...201) = "bar" │ │ │ ├── message_loc: (25,2)-(25,5) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: │ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (202...229)) │ │ │ │ @ BlockNode (location: (25,6)-(28,5))
│ │ │ │ ├── locals: [] │ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅ │ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body: │ │ │ │ ├── body:
│ │ │ │ │ @ StatementsNode (location: (209...223)) │ │ │ │ │ @ StatementsNode (location: (26,4)-(27,7))
│ │ │ │ │ └── body: (length: 1) │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (209...223)) │ │ │ │ │ └── @ CallNode (location: (26,4)-(27,7))
│ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (209...212) = "baz" │ │ │ │ │ ├── message_loc: (26,4)-(26,7) = "baz"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block: │ │ │ │ │ ├── block:
│ │ │ │ │ │ @ BlockNode (location: (213...223)) │ │ │ │ │ │ @ BlockNode (location: (26,8)-(27,7))
│ │ │ │ │ │ ├── locals: [] │ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ ├── parameters: ∅ │ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ ├── body: ∅ │ │ │ │ │ │ ├── body: ∅
│ │ │ │ │ │ ├── opening_loc: (213...215) = "do" │ │ │ │ │ │ ├── opening_loc: (26,8)-(26,10) = "do"
│ │ │ │ │ │ └── closing_loc: (220...223) = "end" │ │ │ │ │ │ └── closing_loc: (27,4)-(27,7) = "end"
│ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "baz" │ │ │ │ │ └── name: "baz"
│ │ │ │ ├── opening_loc: (202...204) = "do" │ │ │ │ ├── opening_loc: (25,6)-(25,8) = "do"
│ │ │ │ └── closing_loc: (226...229) = "end" │ │ │ │ └── closing_loc: (28,2)-(28,5) = "end"
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── opening_loc: (193...195) = "do" │ │ ├── opening_loc: (24,4)-(24,6) = "do"
│ │ └── closing_loc: (230...233) = "end" │ │ └── closing_loc: (29,0)-(29,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (235...251)) ├── @ CallNode (location: (31,0)-(31,16))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (235...238)) │ │ @ CallNode (location: (31,0)-(31,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (235...238) = "foo" │ │ ├── message_loc: (31,0)-(31,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -443,106 +443,106 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (238...243) = "[bar]" │ ├── message_loc: (31,3)-(31,8) = "[bar]"
│ ├── opening_loc: (238...239) = "[" │ ├── opening_loc: (31,3)-(31,4) = "["
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (239...242)) │ │ @ ArgumentsNode (location: (31,4)-(31,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (239...242)) │ │ └── @ CallNode (location: (31,4)-(31,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (239...242) = "bar" │ │ ├── message_loc: (31,4)-(31,7) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── closing_loc: (242...243) = "]" │ ├── closing_loc: (31,7)-(31,8) = "]"
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (244...251)) │ │ @ BlockNode (location: (31,9)-(31,16))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (246...249)) │ │ │ @ StatementsNode (location: (31,11)-(31,14))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (246...249)) │ │ │ └── @ CallNode (location: (31,11)-(31,14))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (246...249) = "baz" │ │ │ ├── message_loc: (31,11)-(31,14) = "baz"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "baz" │ │ │ └── name: "baz"
│ │ ├── opening_loc: (244...245) = "{" │ │ ├── opening_loc: (31,9)-(31,10) = "{"
│ │ └── closing_loc: (250...251) = "}" │ │ └── closing_loc: (31,15)-(31,16) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "[]" │ └── name: "[]"
├── @ CallNode (location: (253...277)) ├── @ CallNode (location: (33,0)-(33,24))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (253...256) = "foo" │ ├── message_loc: (33,0)-(33,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (257...277)) │ │ @ BlockNode (location: (33,4)-(33,24))
│ │ ├── locals: [:x, :y, :z] │ │ ├── locals: [:x, :y, :z]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (259...273)) │ │ │ @ BlockParametersNode (location: (33,6)-(33,20))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (260...272)) │ │ │ │ @ ParametersNode (location: (33,7)-(33,19))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (260...261)) │ │ │ │ │ └── @ RequiredParameterNode (location: (33,7)-(33,8))
│ │ │ │ │ └── name: :x │ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 1) │ │ │ │ ├── optionals: (length: 1)
│ │ │ │ │ └── @ OptionalParameterNode (location: (263...268)) │ │ │ │ │ └── @ OptionalParameterNode (location: (33,10)-(33,15))
│ │ │ │ │ ├── name: :y │ │ │ │ │ ├── name: :y
│ │ │ │ │ ├── name_loc: (263...264) = "y" │ │ │ │ │ ├── name_loc: (33,10)-(33,11) = "y"
│ │ │ │ │ ├── operator_loc: (265...266) = "=" │ │ │ │ │ ├── operator_loc: (33,12)-(33,13) = "="
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (267...268)) │ │ │ │ │ @ IntegerNode (location: (33,14)-(33,15))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
│ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── posts: (length: 0)
│ │ │ │ ├── keywords: (length: 1) │ │ │ │ ├── keywords: (length: 1)
│ │ │ │ │ └── @ KeywordParameterNode (location: (270...272)) │ │ │ │ │ └── @ KeywordParameterNode (location: (33,17)-(33,19))
│ │ │ │ │ ├── name: :z │ │ │ │ │ ├── name: :z
│ │ │ │ │ ├── name_loc: (270...272) = "z:" │ │ │ │ │ ├── name_loc: (33,17)-(33,19) = "z:"
│ │ │ │ │ └── value: ∅ │ │ │ │ │ └── value: ∅
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (259...260) = "|" │ │ │ ├── opening_loc: (33,6)-(33,7) = "|"
│ │ │ └── closing_loc: (272...273) = "|" │ │ │ └── closing_loc: (33,19)-(33,20) = "|"
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (274...275)) │ │ │ @ StatementsNode (location: (33,21)-(33,22))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableReadNode (location: (274...275)) │ │ │ └── @ LocalVariableReadNode (location: (33,21)-(33,22))
│ │ │ ├── name: :x │ │ │ ├── name: :x
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── opening_loc: (257...258) = "{" │ │ ├── opening_loc: (33,4)-(33,5) = "{"
│ │ └── closing_loc: (276...277) = "}" │ │ └── closing_loc: (33,23)-(33,24) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ CallNode (location: (279...290)) ├── @ CallNode (location: (35,0)-(35,11))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (279...282) = "foo" │ ├── message_loc: (35,0)-(35,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (283...290)) │ │ @ BlockNode (location: (35,4)-(35,11))
│ │ ├── locals: [:x] │ │ ├── locals: [:x]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (285...288)) │ │ │ @ BlockParametersNode (location: (35,6)-(35,9))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (286...287)) │ │ │ │ @ ParametersNode (location: (35,7)-(35,8))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (286...287)) │ │ │ │ │ └── @ RequiredParameterNode (location: (35,7)-(35,8))
│ │ │ │ │ └── name: :x │ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -551,37 +551,37 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (285...286) = "|" │ │ │ ├── opening_loc: (35,6)-(35,7) = "|"
│ │ │ └── closing_loc: (287...288) = "|" │ │ │ └── closing_loc: (35,8)-(35,9) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (283...284) = "{" │ │ ├── opening_loc: (35,4)-(35,5) = "{"
│ │ └── closing_loc: (289...290) = "}" │ │ └── closing_loc: (35,10)-(35,11) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ LocalVariableWriteNode (location: (292...300)) ├── @ LocalVariableWriteNode (location: (37,0)-(37,8))
│ ├── name: :fork │ ├── name: :fork
│ ├── depth: 0 │ ├── depth: 0
│ ├── name_loc: (292...296) = "fork" │ ├── name_loc: (37,0)-(37,4) = "fork"
│ ├── value: │ ├── value:
│ │ @ IntegerNode (location: (299...300)) │ │ @ IntegerNode (location: (37,7)-(37,8))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (297...298) = "=" │ └── operator_loc: (37,5)-(37,6) = "="
├── @ CallNode (location: (301...316)) ├── @ CallNode (location: (38,0)-(39,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (301...305) = "fork" │ ├── message_loc: (38,0)-(38,4) = "fork"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (306...316)) │ │ @ BlockNode (location: (38,5)-(39,3))
│ │ ├── locals: [:a] │ │ ├── locals: [:a]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (309...312)) │ │ │ @ BlockParametersNode (location: (38,8)-(38,11))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (310...311)) │ │ │ │ @ ParametersNode (location: (38,9)-(38,10))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (310...311)) │ │ │ │ │ └── @ RequiredParameterNode (location: (38,9)-(38,10))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -590,29 +590,29 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (309...310) = "|" │ │ │ ├── opening_loc: (38,8)-(38,9) = "|"
│ │ │ └── closing_loc: (311...312) = "|" │ │ │ └── closing_loc: (38,10)-(38,11) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (306...308) = "do" │ │ ├── opening_loc: (38,5)-(38,7) = "do"
│ │ └── closing_loc: (313...316) = "end" │ │ └── closing_loc: (39,0)-(39,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "fork" │ └── name: "fork"
├── @ CallNode (location: (318...330)) ├── @ CallNode (location: (41,0)-(41,12))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (318...322) = "fork" │ ├── message_loc: (41,0)-(41,4) = "fork"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (323...330)) │ │ @ BlockNode (location: (41,5)-(41,12))
│ │ ├── locals: [:a] │ │ ├── locals: [:a]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (325...328)) │ │ │ @ BlockParametersNode (location: (41,7)-(41,10))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (326...327)) │ │ │ │ @ ParametersNode (location: (41,8)-(41,9))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (326...327)) │ │ │ │ │ └── @ RequiredParameterNode (location: (41,8)-(41,9))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -621,130 +621,130 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (325...326) = "|" │ │ │ ├── opening_loc: (41,7)-(41,8) = "|"
│ │ │ └── closing_loc: (327...328) = "|" │ │ │ └── closing_loc: (41,9)-(41,10) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (323...324) = "{" │ │ ├── opening_loc: (41,5)-(41,6) = "{"
│ │ └── closing_loc: (329...330) = "}" │ │ └── closing_loc: (41,11)-(41,12) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "fork" │ └── name: "fork"
├── @ CallNode (location: (332...340)) ├── @ CallNode (location: (43,0)-(44,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (332...333) = "C" │ ├── message_loc: (43,0)-(43,1) = "C"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (334...340)) │ │ @ BlockNode (location: (43,2)-(44,3))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (334...336) = "do" │ │ ├── opening_loc: (43,2)-(43,4) = "do"
│ │ └── closing_loc: (337...340) = "end" │ │ └── closing_loc: (44,0)-(44,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "C" │ └── name: "C"
├── @ CallNode (location: (342...346)) ├── @ CallNode (location: (46,0)-(46,4))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (342...343) = "C" │ ├── message_loc: (46,0)-(46,1) = "C"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (344...346)) │ │ @ BlockNode (location: (46,2)-(46,4))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (344...345) = "{" │ │ ├── opening_loc: (46,2)-(46,3) = "{"
│ │ └── closing_loc: (345...346) = "}" │ │ └── closing_loc: (46,3)-(46,4) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "C" │ └── name: "C"
├── @ CallNode (location: (348...383)) ├── @ CallNode (location: (48,0)-(52,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (348...351) = "foo" │ ├── message_loc: (48,0)-(48,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (352...383)) │ │ @ ArgumentsNode (location: (48,4)-(52,1))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (352...383)) │ │ └── @ CallNode (location: (48,4)-(52,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (352...358) = "lambda" │ │ ├── message_loc: (48,4)-(48,10) = "lambda"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: │ │ ├── block:
│ │ │ @ BlockNode (location: (359...383)) │ │ │ @ BlockNode (location: (48,11)-(52,1))
│ │ │ ├── locals: [:a, :b] │ │ │ ├── locals: [:a, :b]
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ BlockParametersNode (location: (361...381)) │ │ │ │ @ BlockParametersNode (location: (48,13)-(51,3))
│ │ │ │ ├── parameters: │ │ │ │ ├── parameters:
│ │ │ │ │ @ ParametersNode (location: (365...377)) │ │ │ │ │ @ ParametersNode (location: (49,2)-(50,6))
│ │ │ │ │ ├── requireds: (length: 0) │ │ │ │ │ ├── requireds: (length: 0)
│ │ │ │ │ ├── optionals: (length: 0) │ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ ├── rest: ∅ │ │ │ │ │ ├── rest: ∅
│ │ │ │ │ ├── posts: (length: 0) │ │ │ │ │ ├── posts: (length: 0)
│ │ │ │ │ ├── keywords: (length: 2) │ │ │ │ │ ├── keywords: (length: 2)
│ │ │ │ │ │ ├── @ KeywordParameterNode (location: (365...369)) │ │ │ │ │ │ ├── @ KeywordParameterNode (location: (49,2)-(49,6))
│ │ │ │ │ │ │ ├── name: :a │ │ │ │ │ │ │ ├── name: :a
│ │ │ │ │ │ │ ├── name_loc: (365...367) = "a:" │ │ │ │ │ │ │ ├── name_loc: (49,2)-(49,4) = "a:"
│ │ │ │ │ │ │ └── value: │ │ │ │ │ │ │ └── value:
│ │ │ │ │ │ │ @ IntegerNode (location: (368...369)) │ │ │ │ │ │ │ @ IntegerNode (location: (49,5)-(49,6))
│ │ │ │ │ │ │ └── flags: decimal │ │ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ │ └── @ KeywordParameterNode (location: (373...377)) │ │ │ │ │ │ └── @ KeywordParameterNode (location: (50,2)-(50,6))
│ │ │ │ │ │ ├── name: :b │ │ │ │ │ │ ├── name: :b
│ │ │ │ │ │ ├── name_loc: (373...375) = "b:" │ │ │ │ │ │ ├── name_loc: (50,2)-(50,4) = "b:"
│ │ │ │ │ │ └── value: │ │ │ │ │ │ └── value:
│ │ │ │ │ │ @ IntegerNode (location: (376...377)) │ │ │ │ │ │ @ IntegerNode (location: (50,5)-(50,6))
│ │ │ │ │ │ └── flags: decimal │ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ └── block: ∅ │ │ │ │ │ └── block: ∅
│ │ │ │ ├── locals: (length: 0) │ │ │ │ ├── locals: (length: 0)
│ │ │ │ ├── opening_loc: (361...362) = "|" │ │ │ │ ├── opening_loc: (48,13)-(48,14) = "|"
│ │ │ │ └── closing_loc: (380...381) = "|" │ │ │ │ └── closing_loc: (51,2)-(51,3) = "|"
│ │ │ ├── body: ∅ │ │ │ ├── body: ∅
│ │ │ ├── opening_loc: (359...360) = "{" │ │ │ ├── opening_loc: (48,11)-(48,12) = "{"
│ │ │ └── closing_loc: (382...383) = "}" │ │ │ └── closing_loc: (52,0)-(52,1) = "}"
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "lambda" │ │ └── name: "lambda"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
└── @ CallNode (location: (385...402)) └── @ CallNode (location: (54,0)-(54,17))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (385...388) = "foo" ├── message_loc: (54,0)-(54,3) = "foo"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (389...402)) │ @ BlockNode (location: (54,4)-(54,17))
│ ├── locals: [:bar] │ ├── locals: [:bar]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (392...398)) │ │ @ BlockParametersNode (location: (54,7)-(54,13))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (393...397)) │ │ │ @ ParametersNode (location: (54,8)-(54,12))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (393...396)) │ │ │ │ └── @ RequiredParameterNode (location: (54,8)-(54,11))
│ │ │ │ └── name: :bar │ │ │ │ └── name: :bar
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (396...397)) │ │ │ │ @ RestParameterNode (location: (54,11)-(54,12))
│ │ │ │ ├── name: nil │ │ │ │ ├── name: nil
│ │ │ │ ├── name_loc: ∅ │ │ │ │ ├── name_loc: ∅
│ │ │ │ └── operator_loc: (396...397) = "," │ │ │ │ └── operator_loc: (54,11)-(54,12) = ","
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (392...393) = "|" │ │ ├── opening_loc: (54,7)-(54,8) = "|"
│ │ └── closing_loc: (397...398) = "|" │ │ └── closing_loc: (54,12)-(54,13) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (389...391) = "do" │ ├── opening_loc: (54,4)-(54,6) = "do"
│ └── closing_loc: (399...402) = "end" │ └── closing_loc: (54,14)-(54,17) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "foo" └── name: "foo"

34
test/yarp/snapshots/boolean_operators.txt
View file

@ -1,16 +1,16 @@
@ ProgramNode (location: (0...24)) @ ProgramNode (location: (1,0)-(5,7))
├── locals: [:a] ├── locals: [:a]
└── statements: └── statements:
@ StatementsNode (location: (0...24)) @ StatementsNode (location: (1,0)-(5,7))
└── body: (length: 3) └── body: (length: 3)
├── @ LocalVariableAndWriteNode (location: (0...7)) ├── @ LocalVariableAndWriteNode (location: (1,0)-(1,7))
│ ├── name_loc: (0...1) = "a" │ ├── name_loc: (1,0)-(1,1) = "a"
│ ├── operator_loc: (2...5) = "&&=" │ ├── operator_loc: (1,2)-(1,5) = "&&="
│ ├── value: │ ├── value:
│ │ @ CallNode (location: (6...7)) │ │ @ CallNode (location: (1,6)-(1,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (6...7) = "b" │ │ ├── message_loc: (1,6)-(1,7) = "b"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -19,14 +19,14 @@
│ │ └── name: "b" │ │ └── name: "b"
│ ├── name: :a │ ├── name: :a
│ └── depth: 0 │ └── depth: 0
├── @ LocalVariableOperatorWriteNode (location: (9...15)) ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,6))
│ ├── name_loc: (9...10) = "a" │ ├── name_loc: (3,0)-(3,1) = "a"
│ ├── operator_loc: (11...13) = "+=" │ ├── operator_loc: (3,2)-(3,4) = "+="
│ ├── value: │ ├── value:
│ │ @ CallNode (location: (14...15)) │ │ @ CallNode (location: (3,5)-(3,6))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (14...15) = "b" │ │ ├── message_loc: (3,5)-(3,6) = "b"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -36,14 +36,14 @@
│ ├── name: :a │ ├── name: :a
│ ├── operator: :+ │ ├── operator: :+
│ └── depth: 0 │ └── depth: 0
└── @ LocalVariableOrWriteNode (location: (17...24)) └── @ LocalVariableOrWriteNode (location: (5,0)-(5,7))
├── name_loc: (17...18) = "a" ├── name_loc: (5,0)-(5,1) = "a"
├── operator_loc: (19...22) = "||=" ├── operator_loc: (5,2)-(5,5) = "||="
├── value: ├── value:
│ @ CallNode (location: (23...24)) │ @ CallNode (location: (5,6)-(5,7))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (23...24) = "b" │ ├── message_loc: (5,6)-(5,7) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅

8
test/yarp/snapshots/booleans.txt
View file

@ -1,7 +1,7 @@
@ ProgramNode (location: (0...11)) @ ProgramNode (location: (1,0)-(3,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...11)) @ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 2) └── body: (length: 2)
├── @ FalseNode (location: (0...5)) ├── @ FalseNode (location: (1,0)-(1,5))
└── @ TrueNode (location: (7...11)) └── @ TrueNode (location: (3,0)-(3,4))

202
test/yarp/snapshots/break.txt
View file

@ -1,178 +1,178 @@
@ ProgramNode (location: (0...168)) @ ProgramNode (location: (1,0)-(25,23))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...168)) @ StatementsNode (location: (1,0)-(25,23))
└── body: (length: 11) └── body: (length: 11)
├── @ BreakNode (location: (0...5)) ├── @ BreakNode (location: (1,0)-(1,5))
│ ├── arguments: ∅ │ ├── arguments: ∅
│ └── keyword_loc: (0...5) = "break" │ └── keyword_loc: (1,0)-(1,5) = "break"
├── @ BreakNode (location: (7...26)) ├── @ BreakNode (location: (3,0)-(3,19))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (13...26)) │ │ @ ArgumentsNode (location: (3,6)-(3,19))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ ParenthesesNode (location: (13...16)) │ │ ├── @ ParenthesesNode (location: (3,6)-(3,9))
│ │ │ ├── body: │ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (14...15)) │ │ │ │ @ StatementsNode (location: (3,7)-(3,8))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (14...15)) │ │ │ │ └── @ IntegerNode (location: (3,7)-(3,8))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (13...14) = "(" │ │ │ ├── opening_loc: (3,6)-(3,7) = "("
│ │ │ └── closing_loc: (15...16) = ")" │ │ │ └── closing_loc: (3,8)-(3,9) = ")"
│ │ ├── @ ParenthesesNode (location: (18...21)) │ │ ├── @ ParenthesesNode (location: (3,11)-(3,14))
│ │ │ ├── body: │ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (19...20)) │ │ │ │ @ StatementsNode (location: (3,12)-(3,13))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (19...20)) │ │ │ │ └── @ IntegerNode (location: (3,12)-(3,13))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (18...19) = "(" │ │ │ ├── opening_loc: (3,11)-(3,12) = "("
│ │ │ └── closing_loc: (20...21) = ")" │ │ │ └── closing_loc: (3,13)-(3,14) = ")"
│ │ └── @ ParenthesesNode (location: (23...26)) │ │ └── @ ParenthesesNode (location: (3,16)-(3,19))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (24...25)) │ │ │ @ StatementsNode (location: (3,17)-(3,18))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (24...25)) │ │ │ └── @ IntegerNode (location: (3,17)-(3,18))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (23...24) = "(" │ │ ├── opening_loc: (3,16)-(3,17) = "("
│ │ └── closing_loc: (25...26) = ")" │ │ └── closing_loc: (3,18)-(3,19) = ")"
│ └── keyword_loc: (7...12) = "break" │ └── keyword_loc: (3,0)-(3,5) = "break"
├── @ BreakNode (location: (28...35)) ├── @ BreakNode (location: (5,0)-(5,7))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (34...35)) │ │ @ ArgumentsNode (location: (5,6)-(5,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (34...35)) │ │ └── @ IntegerNode (location: (5,6)-(5,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (28...33) = "break" │ └── keyword_loc: (5,0)-(5,5) = "break"
├── @ BreakNode (location: (37...50)) ├── @ BreakNode (location: (7,0)-(8,1))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (43...50)) │ │ @ ArgumentsNode (location: (7,6)-(8,1))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (43...44)) │ │ ├── @ IntegerNode (location: (7,6)-(7,7))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (46...47)) │ │ ├── @ IntegerNode (location: (7,9)-(7,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (49...50)) │ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (37...42) = "break" │ └── keyword_loc: (7,0)-(7,5) = "break"
├── @ BreakNode (location: (52...65)) ├── @ BreakNode (location: (10,0)-(10,13))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (58...65)) │ │ @ ArgumentsNode (location: (10,6)-(10,13))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (58...59)) │ │ ├── @ IntegerNode (location: (10,6)-(10,7))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (61...62)) │ │ ├── @ IntegerNode (location: (10,9)-(10,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (64...65)) │ │ └── @ IntegerNode (location: (10,12)-(10,13))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (52...57) = "break" │ └── keyword_loc: (10,0)-(10,5) = "break"
├── @ BreakNode (location: (67...82)) ├── @ BreakNode (location: (12,0)-(12,15))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (73...82)) │ │ @ ArgumentsNode (location: (12,6)-(12,15))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ArrayNode (location: (73...82)) │ │ └── @ ArrayNode (location: (12,6)-(12,15))
│ │ ├── elements: (length: 3) │ │ ├── elements: (length: 3)
│ │ │ ├── @ IntegerNode (location: (74...75)) │ │ │ ├── @ IntegerNode (location: (12,7)-(12,8))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── @ IntegerNode (location: (77...78)) │ │ │ ├── @ IntegerNode (location: (12,10)-(12,11))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (80...81)) │ │ │ └── @ IntegerNode (location: (12,13)-(12,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (73...74) = "[" │ │ ├── opening_loc: (12,6)-(12,7) = "["
│ │ └── closing_loc: (81...82) = "]" │ │ └── closing_loc: (12,14)-(12,15) = "]"
│ └── keyword_loc: (67...72) = "break" │ └── keyword_loc: (12,0)-(12,5) = "break"
├── @ BreakNode (location: (84...100)) ├── @ BreakNode (location: (14,0)-(17,1))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (89...100)) │ │ @ ArgumentsNode (location: (14,5)-(17,1))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (89...100)) │ │ └── @ ParenthesesNode (location: (14,5)-(17,1))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (93...98)) │ │ │ @ StatementsNode (location: (15,2)-(16,3))
│ │ │ └── body: (length: 2) │ │ │ └── body: (length: 2)
│ │ │ ├── @ IntegerNode (location: (93...94)) │ │ │ ├── @ IntegerNode (location: (15,2)-(15,3))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (97...98)) │ │ │ └── @ IntegerNode (location: (16,2)-(16,3))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (89...90) = "(" │ │ ├── opening_loc: (14,5)-(14,6) = "("
│ │ └── closing_loc: (99...100) = ")" │ │ └── closing_loc: (17,0)-(17,1) = ")"
│ └── keyword_loc: (84...89) = "break" │ └── keyword_loc: (14,0)-(14,5) = "break"
├── @ BreakNode (location: (102...109)) ├── @ BreakNode (location: (19,0)-(19,7))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (107...109)) │ │ @ ArgumentsNode (location: (19,5)-(19,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (107...109)) │ │ └── @ ParenthesesNode (location: (19,5)-(19,7))
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (107...108) = "(" │ │ ├── opening_loc: (19,5)-(19,6) = "("
│ │ └── closing_loc: (108...109) = ")" │ │ └── closing_loc: (19,6)-(19,7) = ")"
│ └── keyword_loc: (102...107) = "break" │ └── keyword_loc: (19,0)-(19,5) = "break"
├── @ BreakNode (location: (111...119)) ├── @ BreakNode (location: (21,0)-(21,8))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (116...119)) │ │ @ ArgumentsNode (location: (21,5)-(21,8))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (116...119)) │ │ └── @ ParenthesesNode (location: (21,5)-(21,8))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (117...118)) │ │ │ @ StatementsNode (location: (21,6)-(21,7))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (117...118)) │ │ │ └── @ IntegerNode (location: (21,6)-(21,7))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (116...117) = "(" │ │ ├── opening_loc: (21,5)-(21,6) = "("
│ │ └── closing_loc: (118...119) = ")" │ │ └── closing_loc: (21,7)-(21,8) = ")"
│ └── keyword_loc: (111...116) = "break" │ └── keyword_loc: (21,0)-(21,5) = "break"
├── @ CallNode (location: (121...143)) ├── @ CallNode (location: (23,0)-(23,22))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (121...137)) │ │ @ CallNode (location: (23,0)-(23,16))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (121...124) = "foo" │ │ ├── message_loc: (23,0)-(23,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: │ │ ├── block:
│ │ │ @ BlockNode (location: (125...137)) │ │ │ @ BlockNode (location: (23,4)-(23,16))
│ │ │ ├── locals: [] │ │ │ ├── locals: []
│ │ │ ├── parameters: ∅ │ │ │ ├── parameters: ∅
│ │ │ ├── body: │ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (127...135)) │ │ │ │ @ StatementsNode (location: (23,6)-(23,14))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ BreakNode (location: (127...135)) │ │ │ │ └── @ BreakNode (location: (23,6)-(23,14))
│ │ │ │ ├── arguments: │ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (133...135)) │ │ │ │ │ @ ArgumentsNode (location: (23,12)-(23,14))
│ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (133...135)) │ │ │ │ │ └── @ IntegerNode (location: (23,12)-(23,14))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ └── keyword_loc: (127...132) = "break" │ │ │ │ └── keyword_loc: (23,6)-(23,11) = "break"
│ │ │ ├── opening_loc: (125...126) = "{" │ │ │ ├── opening_loc: (23,4)-(23,5) = "{"
│ │ │ └── closing_loc: (136...137) = "}" │ │ │ └── closing_loc: (23,15)-(23,16) = "}"
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (138...140) = "==" │ ├── message_loc: (23,17)-(23,19) = "=="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (141...143)) │ │ @ ArgumentsNode (location: (23,20)-(23,22))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (141...143)) │ │ └── @ IntegerNode (location: (23,20)-(23,22))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "==" │ └── name: "=="
└── @ CallNode (location: (145...168)) └── @ CallNode (location: (25,0)-(25,23))
├── receiver: ├── receiver:
│ @ CallNode (location: (145...162)) │ @ CallNode (location: (25,0)-(25,17))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (145...148) = "foo" │ ├── message_loc: (25,0)-(25,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (149...162)) │ │ @ BlockNode (location: (25,4)-(25,17))
│ │ ├── locals: [:a] │ │ ├── locals: [:a]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (151...154)) │ │ │ @ BlockParametersNode (location: (25,6)-(25,9))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (152...153)) │ │ │ │ @ ParametersNode (location: (25,7)-(25,8))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (152...153)) │ │ │ │ │ └── @ RequiredParameterNode (location: (25,7)-(25,8))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -181,25 +181,25 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (151...152) = "|" │ │ │ ├── opening_loc: (25,6)-(25,7) = "|"
│ │ │ └── closing_loc: (153...154) = "|" │ │ │ └── closing_loc: (25,8)-(25,9) = "|"
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (155...160)) │ │ │ @ StatementsNode (location: (25,10)-(25,15))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ BreakNode (location: (155...160)) │ │ │ └── @ BreakNode (location: (25,10)-(25,15))
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ └── keyword_loc: (155...160) = "break" │ │ │ └── keyword_loc: (25,10)-(25,15) = "break"
│ │ ├── opening_loc: (149...150) = "{" │ │ ├── opening_loc: (25,4)-(25,5) = "{"
│ │ └── closing_loc: (161...162) = "}" │ │ └── closing_loc: (25,16)-(25,17) = "}"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (163...165) = "==" ├── message_loc: (25,18)-(25,20) = "=="
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (166...168)) │ @ ArgumentsNode (location: (25,21)-(25,23))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (166...168)) │ └── @ IntegerNode (location: (25,21)-(25,23))
│ └── flags: decimal │ └── flags: decimal
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅

228
test/yarp/snapshots/case.txt
View file

@ -1,74 +1,74 @@
@ ProgramNode (location: (0...299)) @ ProgramNode (location: (1,0)-(32,25))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...299)) @ StatementsNode (location: (1,0)-(32,25))
└── body: (length: 9) └── body: (length: 9)
├── @ CaseNode (location: (0...21)) ├── @ CaseNode (location: (1,0)-(3,3))
│ ├── predicate: │ ├── predicate:
│ │ @ SymbolNode (location: (5...8)) │ │ @ SymbolNode (location: (1,5)-(1,8))
│ │ ├── opening_loc: (5...6) = ":" │ │ ├── opening_loc: (1,5)-(1,6) = ":"
│ │ ├── value_loc: (6...8) = "hi" │ │ ├── value_loc: (1,6)-(1,8) = "hi"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "hi" │ │ └── unescaped: "hi"
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (9...17)) │ │ └── @ WhenNode (location: (2,0)-(2,8))
│ │ ├── keyword_loc: (9...13) = "when" │ │ ├── keyword_loc: (2,0)-(2,4) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (14...17)) │ │ │ └── @ SymbolNode (location: (2,5)-(2,8))
│ │ │ ├── opening_loc: (14...15) = ":" │ │ │ ├── opening_loc: (2,5)-(2,6) = ":"
│ │ │ ├── value_loc: (15...17) = "hi" │ │ │ ├── value_loc: (2,6)-(2,8) = "hi"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "hi" │ │ │ └── unescaped: "hi"
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ ├── case_keyword_loc: (0...4) = "case" │ ├── case_keyword_loc: (1,0)-(1,4) = "case"
│ └── end_keyword_loc: (18...21) = "end" │ └── end_keyword_loc: (3,0)-(3,3) = "end"
├── @ CaseNode (location: (23...81)) ├── @ CaseNode (location: (5,0)-(5,58))
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (28...32)) │ │ @ TrueNode (location: (5,5)-(5,9))
│ ├── conditions: (length: 2) │ ├── conditions: (length: 2)
│ │ ├── @ WhenNode (location: (34...53)) │ │ ├── @ WhenNode (location: (5,11)-(5,30))
│ │ │ ├── keyword_loc: (34...38) = "when" │ │ │ ├── keyword_loc: (5,11)-(5,15) = "when"
│ │ │ ├── conditions: (length: 1) │ │ │ ├── conditions: (length: 1)
│ │ │ │ └── @ TrueNode (location: (39...43)) │ │ │ │ └── @ TrueNode (location: (5,16)-(5,20))
│ │ │ └── statements: │ │ │ └── statements:
│ │ │ @ StatementsNode (location: (45...53)) │ │ │ @ StatementsNode (location: (5,22)-(5,30))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (45...53)) │ │ │ └── @ CallNode (location: (5,22)-(5,30))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (45...49) = "puts" │ │ │ ├── message_loc: (5,22)-(5,26) = "puts"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: │ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (50...53)) │ │ │ │ @ ArgumentsNode (location: (5,27)-(5,30))
│ │ │ │ └── arguments: (length: 1) │ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ SymbolNode (location: (50...53)) │ │ │ │ └── @ SymbolNode (location: (5,27)-(5,30))
│ │ │ │ ├── opening_loc: (50...51) = ":" │ │ │ │ ├── opening_loc: (5,27)-(5,28) = ":"
│ │ │ │ ├── value_loc: (51...53) = "hi" │ │ │ │ ├── value_loc: (5,28)-(5,30) = "hi"
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "hi" │ │ │ │ └── unescaped: "hi"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "puts" │ │ │ └── name: "puts"
│ │ └── @ WhenNode (location: (55...76)) │ │ └── @ WhenNode (location: (5,32)-(5,53))
│ │ ├── keyword_loc: (55...59) = "when" │ │ ├── keyword_loc: (5,32)-(5,36) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ FalseNode (location: (60...65)) │ │ │ └── @ FalseNode (location: (5,37)-(5,42))
│ │ └── statements: │ │ └── statements:
│ │ @ StatementsNode (location: (67...76)) │ │ @ StatementsNode (location: (5,44)-(5,53))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (67...76)) │ │ └── @ CallNode (location: (5,44)-(5,53))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (67...71) = "puts" │ │ ├── message_loc: (5,44)-(5,48) = "puts"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (72...76)) │ │ │ @ ArgumentsNode (location: (5,49)-(5,53))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ SymbolNode (location: (72...76)) │ │ │ └── @ SymbolNode (location: (5,49)-(5,53))
│ │ │ ├── opening_loc: (72...73) = ":" │ │ │ ├── opening_loc: (5,49)-(5,50) = ":"
│ │ │ ├── value_loc: (73...76) = "bye" │ │ │ ├── value_loc: (5,50)-(5,53) = "bye"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "bye" │ │ │ └── unescaped: "bye"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -76,21 +76,21 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "puts" │ │ └── name: "puts"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ ├── case_keyword_loc: (23...27) = "case" │ ├── case_keyword_loc: (5,0)-(5,4) = "case"
│ └── end_keyword_loc: (78...81) = "end" │ └── end_keyword_loc: (5,55)-(5,58) = "end"
├── @ CaseNode (location: (83...103)) ├── @ CaseNode (location: (7,0)-(7,20))
│ ├── predicate: ∅ │ ├── predicate: ∅
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (89...98)) │ │ └── @ WhenNode (location: (7,6)-(7,15))
│ │ ├── keyword_loc: (89...93) = "when" │ │ ├── keyword_loc: (7,6)-(7,10) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ SplatNode (location: (94...98)) │ │ │ └── @ SplatNode (location: (7,11)-(7,15))
│ │ │ ├── operator_loc: (94...95) = "*" │ │ │ ├── operator_loc: (7,11)-(7,12) = "*"
│ │ │ └── expression: │ │ │ └── expression:
│ │ │ @ CallNode (location: (95...98)) │ │ │ @ CallNode (location: (7,12)-(7,15))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (95...98) = "foo" │ │ │ ├── message_loc: (7,12)-(7,15) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -99,45 +99,45 @@
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ ├── case_keyword_loc: (83...87) = "case" │ ├── case_keyword_loc: (7,0)-(7,4) = "case"
│ └── end_keyword_loc: (100...103) = "end" │ └── end_keyword_loc: (7,17)-(7,20) = "end"
├── @ CaseNode (location: (105...134)) ├── @ CaseNode (location: (9,0)-(13,3))
│ ├── predicate: │ ├── predicate:
│ │ @ SymbolNode (location: (110...113)) │ │ @ SymbolNode (location: (9,5)-(9,8))
│ │ ├── opening_loc: (110...111) = ":" │ │ ├── opening_loc: (9,5)-(9,6) = ":"
│ │ ├── value_loc: (111...113) = "hi" │ │ ├── value_loc: (9,6)-(9,8) = "hi"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "hi" │ │ └── unescaped: "hi"
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (114...122)) │ │ └── @ WhenNode (location: (10,0)-(10,8))
│ │ ├── keyword_loc: (114...118) = "when" │ │ ├── keyword_loc: (10,0)-(10,4) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (119...122)) │ │ │ └── @ SymbolNode (location: (10,5)-(10,8))
│ │ │ ├── opening_loc: (119...120) = ":" │ │ │ ├── opening_loc: (10,5)-(10,6) = ":"
│ │ │ ├── value_loc: (120...122) = "hi" │ │ │ ├── value_loc: (10,6)-(10,8) = "hi"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "hi" │ │ │ └── unescaped: "hi"
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (123...134)) │ │ @ ElseNode (location: (11,0)-(13,3))
│ │ ├── else_keyword_loc: (123...127) = "else" │ │ ├── else_keyword_loc: (11,0)-(11,4) = "else"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (128...130)) │ │ │ @ StatementsNode (location: (12,0)-(12,2))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ SymbolNode (location: (128...130)) │ │ │ └── @ SymbolNode (location: (12,0)-(12,2))
│ │ │ ├── opening_loc: (128...129) = ":" │ │ │ ├── opening_loc: (12,0)-(12,1) = ":"
│ │ │ ├── value_loc: (129...130) = "b" │ │ │ ├── value_loc: (12,1)-(12,2) = "b"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "b" │ │ │ └── unescaped: "b"
│ │ └── end_keyword_loc: (131...134) = "end" │ │ └── end_keyword_loc: (13,0)-(13,3) = "end"
│ ├── case_keyword_loc: (105...109) = "case" │ ├── case_keyword_loc: (9,0)-(9,4) = "case"
│ └── end_keyword_loc: (131...134) = "end" │ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ CaseNode (location: (136...172)) ├── @ CaseNode (location: (15,0)-(15,36))
│ ├── predicate: │ ├── predicate:
│ │ @ CallNode (location: (141...145)) │ │ @ CallNode (location: (15,5)-(15,9))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (141...145) = "this" │ │ ├── message_loc: (15,5)-(15,9) = "this"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -145,29 +145,29 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "this" │ │ └── name: "this"
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (147...167)) │ │ └── @ WhenNode (location: (15,11)-(15,31))
│ │ ├── keyword_loc: (147...151) = "when" │ │ ├── keyword_loc: (15,11)-(15,15) = "when"
│ │ ├── conditions: (length: 2) │ │ ├── conditions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (152...158)) │ │ │ ├── @ ConstantReadNode (location: (15,16)-(15,22))
│ │ │ │ └── name: :FooBar │ │ │ │ └── name: :FooBar
│ │ │ └── @ ConstantReadNode (location: (160...167)) │ │ │ └── @ ConstantReadNode (location: (15,24)-(15,31))
│ │ │ └── name: :BazBonk │ │ │ └── name: :BazBonk
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ ├── case_keyword_loc: (136...140) = "case" │ ├── case_keyword_loc: (15,0)-(15,4) = "case"
│ └── end_keyword_loc: (169...172) = "end" │ └── end_keyword_loc: (15,33)-(15,36) = "end"
├── @ CaseNode (location: (174...198)) ├── @ CaseNode (location: (17,0)-(19,3))
│ ├── predicate: ∅ │ ├── predicate: ∅
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (179...194)) │ │ └── @ WhenNode (location: (18,0)-(18,15))
│ │ ├── keyword_loc: (179...183) = "when" │ │ ├── keyword_loc: (18,0)-(18,4) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ CallNode (location: (184...194)) │ │ │ └── @ CallNode (location: (18,5)-(18,15))
│ │ │ ├── receiver: │ │ │ ├── receiver:
│ │ │ │ @ CallNode (location: (184...187)) │ │ │ │ @ CallNode (location: (18,5)-(18,8))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (184...187) = "foo" │ │ │ │ ├── message_loc: (18,5)-(18,8) = "foo"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -175,15 +175,15 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "foo" │ │ │ │ └── name: "foo"
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (188...190) = "==" │ │ │ ├── message_loc: (18,9)-(18,11) = "=="
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: │ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (191...194)) │ │ │ │ @ ArgumentsNode (location: (18,12)-(18,15))
│ │ │ │ └── arguments: (length: 1) │ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ CallNode (location: (191...194)) │ │ │ │ └── @ CallNode (location: (18,12)-(18,15))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (191...194) = "bar" │ │ │ │ ├── message_loc: (18,12)-(18,15) = "bar"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -196,18 +196,18 @@
│ │ │ └── name: "==" │ │ │ └── name: "=="
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ ├── case_keyword_loc: (174...178) = "case" │ ├── case_keyword_loc: (17,0)-(17,4) = "case"
│ └── end_keyword_loc: (195...198) = "end" │ └── end_keyword_loc: (19,0)-(19,3) = "end"
├── @ CaseNode (location: (200...230)) ├── @ CaseNode (location: (21,0)-(25,3))
│ ├── predicate: ∅ │ ├── predicate: ∅
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (205...211)) │ │ └── @ WhenNode (location: (22,0)-(22,6))
│ │ ├── keyword_loc: (205...209) = "when" │ │ ├── keyword_loc: (22,0)-(22,4) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ CallNode (location: (210...211)) │ │ │ └── @ CallNode (location: (22,5)-(22,6))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (210...211) = "a" │ │ │ ├── message_loc: (22,5)-(22,6) = "a"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -216,18 +216,18 @@
│ │ │ └── name: "a" │ │ │ └── name: "a"
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (212...230)) │ │ @ ElseNode (location: (23,0)-(25,3))
│ │ ├── else_keyword_loc: (212...216) = "else" │ │ ├── else_keyword_loc: (23,0)-(23,4) = "else"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (227...230) = "end" │ │ └── end_keyword_loc: (25,0)-(25,3) = "end"
│ ├── case_keyword_loc: (200...204) = "case" │ ├── case_keyword_loc: (21,0)-(21,4) = "case"
│ └── end_keyword_loc: (227...230) = "end" │ └── end_keyword_loc: (25,0)-(25,3) = "end"
├── @ CaseNode (location: (232...272)) ├── @ CaseNode (location: (27,0)-(30,6))
│ ├── predicate: │ ├── predicate:
│ │ @ CallNode (location: (237...241)) │ │ @ CallNode (location: (27,5)-(27,9))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (237...241) = "type" │ │ ├── message_loc: (27,5)-(27,9) = "type"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -235,31 +235,31 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "type" │ │ └── name: "type"
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (246...253)) │ │ └── @ WhenNode (location: (28,3)-(28,10))
│ │ ├── keyword_loc: (246...250) = "when" │ │ ├── keyword_loc: (28,3)-(28,7) = "when"
│ │ ├── conditions: (length: 1) │ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (251...253)) │ │ │ └── @ SymbolNode (location: (28,8)-(28,10))
│ │ │ ├── opening_loc: (251...252) = ":" │ │ │ ├── opening_loc: (28,8)-(28,9) = ":"
│ │ │ ├── value_loc: (252...253) = "b" │ │ │ ├── value_loc: (28,9)-(28,10) = "b"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "b" │ │ │ └── unescaped: "b"
│ │ └── statements: ∅ │ │ └── statements: ∅
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (260...272)) │ │ @ ElseNode (location: (29,5)-(30,6))
│ │ ├── else_keyword_loc: (260...264) = "else" │ │ ├── else_keyword_loc: (29,5)-(29,9) = "else"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (269...272) = "end" │ │ └── end_keyword_loc: (30,3)-(30,6) = "end"
│ ├── case_keyword_loc: (232...236) = "case" │ ├── case_keyword_loc: (27,0)-(27,4) = "case"
│ └── end_keyword_loc: (269...272) = "end" │ └── end_keyword_loc: (30,3)-(30,6) = "end"
└── @ CaseNode (location: (274...299)) └── @ CaseNode (location: (32,0)-(32,25))
├── predicate: ∅ ├── predicate: ∅
├── conditions: (length: 1) ├── conditions: (length: 1)
│ └── @ WhenNode (location: (288...294)) │ └── @ WhenNode (location: (32,14)-(32,20))
│ ├── keyword_loc: (288...292) = "when" │ ├── keyword_loc: (32,14)-(32,18) = "when"
│ ├── conditions: (length: 1) │ ├── conditions: (length: 1)
│ │ └── @ IntegerNode (location: (293...294)) │ │ └── @ IntegerNode (location: (32,19)-(32,20))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── statements: ∅ │ └── statements: ∅
├── consequent: ∅ ├── consequent: ∅
├── case_keyword_loc: (274...278) = "case" ├── case_keyword_loc: (32,0)-(32,4) = "case"
└── end_keyword_loc: (296...299) = "end" └── end_keyword_loc: (32,22)-(32,25) = "end"

300
test/yarp/snapshots/classes.txt
View file

@ -1,118 +1,118 @@
@ ProgramNode (location: (0...370)) @ ProgramNode (location: (1,0)-(35,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...370)) @ StatementsNode (location: (1,0)-(35,3))
└── body: (length: 14) └── body: (length: 14)
├── @ ClassNode (location: (0...17)) ├── @ ClassNode (location: (1,0)-(1,17))
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── class_keyword_loc: (0...5) = "class" │ ├── class_keyword_loc: (1,0)-(1,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (6...7)) │ │ @ ConstantReadNode (location: (1,6)-(1,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (8...13)) │ │ @ StatementsNode (location: (1,8)-(1,13))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (8...13)) │ │ └── @ LocalVariableWriteNode (location: (1,8)-(1,13))
│ │ ├── name: :a │ │ ├── name: :a
│ │ ├── depth: 0 │ │ ├── depth: 0
│ │ ├── name_loc: (8...9) = "a" │ │ ├── name_loc: (1,8)-(1,9) = "a"
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (12...13)) │ │ │ @ IntegerNode (location: (1,12)-(1,13))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── operator_loc: (10...11) = "=" │ │ └── operator_loc: (1,10)-(1,11) = "="
│ ├── end_keyword_loc: (14...17) = "end" │ ├── end_keyword_loc: (1,14)-(1,17) = "end"
│ └── name: :A │ └── name: :A
├── @ ClassNode (location: (19...39)) ├── @ ClassNode (location: (3,0)-(3,20))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (19...24) = "class" │ ├── class_keyword_loc: (3,0)-(3,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (25...26)) │ │ @ ConstantReadNode (location: (3,6)-(3,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ BeginNode (location: (28...39)) │ │ @ BeginNode (location: (3,9)-(3,20))
│ │ ├── begin_keyword_loc: ∅ │ │ ├── begin_keyword_loc: ∅
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ ├── rescue_clause: ∅ │ │ ├── rescue_clause: ∅
│ │ ├── else_clause: ∅ │ │ ├── else_clause: ∅
│ │ ├── ensure_clause: │ │ ├── ensure_clause:
│ │ │ @ EnsureNode (location: (28...39)) │ │ │ @ EnsureNode (location: (3,9)-(3,20))
│ │ │ ├── ensure_keyword_loc: (28...34) = "ensure" │ │ │ ├── ensure_keyword_loc: (3,9)-(3,15) = "ensure"
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (36...39) = "end" │ │ │ └── end_keyword_loc: (3,17)-(3,20) = "end"
│ │ └── end_keyword_loc: (36...39) = "end" │ │ └── end_keyword_loc: (3,17)-(3,20) = "end"
│ ├── end_keyword_loc: (36...39) = "end" │ ├── end_keyword_loc: (3,17)-(3,20) = "end"
│ └── name: :A │ └── name: :A
├── @ ClassNode (location: (41...75)) ├── @ ClassNode (location: (5,0)-(5,34))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (41...46) = "class" │ ├── class_keyword_loc: (5,0)-(5,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (47...48)) │ │ @ ConstantReadNode (location: (5,6)-(5,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ BeginNode (location: (50...75)) │ │ @ BeginNode (location: (5,9)-(5,34))
│ │ ├── begin_keyword_loc: ∅ │ │ ├── begin_keyword_loc: ∅
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ ├── rescue_clause: │ │ ├── rescue_clause:
│ │ │ @ RescueNode (location: (50...56)) │ │ │ @ RescueNode (location: (5,9)-(5,15))
│ │ │ ├── keyword_loc: (50...56) = "rescue" │ │ │ ├── keyword_loc: (5,9)-(5,15) = "rescue"
│ │ │ ├── exceptions: (length: 0) │ │ │ ├── exceptions: (length: 0)
│ │ │ ├── operator_loc: ∅ │ │ │ ├── operator_loc: ∅
│ │ │ ├── reference: ∅ │ │ │ ├── reference: ∅
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ └── consequent: ∅ │ │ │ └── consequent: ∅
│ │ ├── else_clause: │ │ ├── else_clause:
│ │ │ @ ElseNode (location: (58...70)) │ │ │ @ ElseNode (location: (5,17)-(5,29))
│ │ │ ├── else_keyword_loc: (58...62) = "else" │ │ │ ├── else_keyword_loc: (5,17)-(5,21) = "else"
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (64...70) = "ensure" │ │ │ └── end_keyword_loc: (5,23)-(5,29) = "ensure"
│ │ ├── ensure_clause: │ │ ├── ensure_clause:
│ │ │ @ EnsureNode (location: (64...75)) │ │ │ @ EnsureNode (location: (5,23)-(5,34))
│ │ │ ├── ensure_keyword_loc: (64...70) = "ensure" │ │ │ ├── ensure_keyword_loc: (5,23)-(5,29) = "ensure"
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (72...75) = "end" │ │ │ └── end_keyword_loc: (5,31)-(5,34) = "end"
│ │ └── end_keyword_loc: (72...75) = "end" │ │ └── end_keyword_loc: (5,31)-(5,34) = "end"
│ ├── end_keyword_loc: (72...75) = "end" │ ├── end_keyword_loc: (5,31)-(5,34) = "end"
│ └── name: :A │ └── name: :A
├── @ ClassNode (location: (77...98)) ├── @ ClassNode (location: (7,0)-(9,3))
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── class_keyword_loc: (77...82) = "class" │ ├── class_keyword_loc: (7,0)-(7,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (83...84)) │ │ @ ConstantReadNode (location: (7,6)-(7,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: (85...86) = "<" │ ├── inheritance_operator_loc: (7,8)-(7,9) = "<"
│ ├── superclass: │ ├── superclass:
│ │ @ ConstantReadNode (location: (87...88)) │ │ @ ConstantReadNode (location: (7,10)-(7,11))
│ │ └── name: :B │ │ └── name: :B
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (89...94)) │ │ @ StatementsNode (location: (8,0)-(8,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (89...94)) │ │ └── @ LocalVariableWriteNode (location: (8,0)-(8,5))
│ │ ├── name: :a │ │ ├── name: :a
│ │ ├── depth: 0 │ │ ├── depth: 0
│ │ ├── name_loc: (89...90) = "a" │ │ ├── name_loc: (8,0)-(8,1) = "a"
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (93...94)) │ │ │ @ IntegerNode (location: (8,4)-(8,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── operator_loc: (91...92) = "=" │ │ └── operator_loc: (8,2)-(8,3) = "="
│ ├── end_keyword_loc: (95...98) = "end" │ ├── end_keyword_loc: (9,0)-(9,3) = "end"
│ └── name: :A │ └── name: :A
├── @ SingletonClassNode (location: (100...120)) ├── @ SingletonClassNode (location: (11,0)-(12,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (100...105) = "class" │ ├── class_keyword_loc: (11,0)-(11,5) = "class"
│ ├── operator_loc: (106...108) = "<<" │ ├── operator_loc: (11,6)-(11,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (109...116)) │ │ @ CallNode (location: (11,9)-(11,16))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (113...116)) │ │ │ @ CallNode (location: (11,13)-(11,16))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (113...116) = "foo" │ │ │ ├── message_loc: (11,13)-(11,16) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -120,7 +120,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (109...112) = "not" │ │ ├── message_loc: (11,9)-(11,12) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -128,101 +128,101 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ ├── body: ∅ │ ├── body: ∅
│ └── end_keyword_loc: (117...120) = "end" │ └── end_keyword_loc: (12,0)-(12,3) = "end"
├── @ ClassNode (location: (122...162)) ├── @ ClassNode (location: (14,0)-(14,40))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (122...127) = "class" │ ├── class_keyword_loc: (14,0)-(14,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (128...129)) │ │ @ ConstantReadNode (location: (14,6)-(14,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (131...157)) │ │ @ StatementsNode (location: (14,9)-(14,35))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ SingletonClassNode (location: (131...157)) │ │ └── @ SingletonClassNode (location: (14,9)-(14,35))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── class_keyword_loc: (131...136) = "class" │ │ ├── class_keyword_loc: (14,9)-(14,14) = "class"
│ │ ├── operator_loc: (137...139) = "<<" │ │ ├── operator_loc: (14,15)-(14,17) = "<<"
│ │ ├── expression: │ │ ├── expression:
│ │ │ @ SelfNode (location: (140...144)) │ │ │ @ SelfNode (location: (14,18)-(14,22))
│ │ ├── body: │ │ ├── body:
│ │ │ @ BeginNode (location: (146...157)) │ │ │ @ BeginNode (location: (14,24)-(14,35))
│ │ │ ├── begin_keyword_loc: ∅ │ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: ∅ │ │ │ ├── rescue_clause: ∅
│ │ │ ├── else_clause: ∅ │ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause: │ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (146...157)) │ │ │ │ @ EnsureNode (location: (14,24)-(14,35))
│ │ │ │ ├── ensure_keyword_loc: (146...152) = "ensure" │ │ │ │ ├── ensure_keyword_loc: (14,24)-(14,30) = "ensure"
│ │ │ │ ├── statements: ∅ │ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (154...157) = "end" │ │ │ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ │ │ └── end_keyword_loc: (154...157) = "end" │ │ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ │ └── end_keyword_loc: (154...157) = "end" │ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ ├── end_keyword_loc: (159...162) = "end" │ ├── end_keyword_loc: (14,37)-(14,40) = "end"
│ └── name: :A │ └── name: :A
├── @ ClassNode (location: (164...218)) ├── @ ClassNode (location: (16,0)-(16,54))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (164...169) = "class" │ ├── class_keyword_loc: (16,0)-(16,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (170...171)) │ │ @ ConstantReadNode (location: (16,6)-(16,7))
│ │ └── name: :A │ │ └── name: :A
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (173...213)) │ │ @ StatementsNode (location: (16,9)-(16,49))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ SingletonClassNode (location: (173...213)) │ │ └── @ SingletonClassNode (location: (16,9)-(16,49))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── class_keyword_loc: (173...178) = "class" │ │ ├── class_keyword_loc: (16,9)-(16,14) = "class"
│ │ ├── operator_loc: (179...181) = "<<" │ │ ├── operator_loc: (16,15)-(16,17) = "<<"
│ │ ├── expression: │ │ ├── expression:
│ │ │ @ SelfNode (location: (182...186)) │ │ │ @ SelfNode (location: (16,18)-(16,22))
│ │ ├── body: │ │ ├── body:
│ │ │ @ BeginNode (location: (188...213)) │ │ │ @ BeginNode (location: (16,24)-(16,49))
│ │ │ ├── begin_keyword_loc: ∅ │ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅ │ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: │ │ │ ├── rescue_clause:
│ │ │ │ @ RescueNode (location: (188...194)) │ │ │ │ @ RescueNode (location: (16,24)-(16,30))
│ │ │ │ ├── keyword_loc: (188...194) = "rescue" │ │ │ │ ├── keyword_loc: (16,24)-(16,30) = "rescue"
│ │ │ │ ├── exceptions: (length: 0) │ │ │ │ ├── exceptions: (length: 0)
│ │ │ │ ├── operator_loc: ∅ │ │ │ │ ├── operator_loc: ∅
│ │ │ │ ├── reference: ∅ │ │ │ │ ├── reference: ∅
│ │ │ │ ├── statements: ∅ │ │ │ │ ├── statements: ∅
│ │ │ │ └── consequent: ∅ │ │ │ │ └── consequent: ∅
│ │ │ ├── else_clause: │ │ │ ├── else_clause:
│ │ │ │ @ ElseNode (location: (196...208)) │ │ │ │ @ ElseNode (location: (16,32)-(16,44))
│ │ │ │ ├── else_keyword_loc: (196...200) = "else" │ │ │ │ ├── else_keyword_loc: (16,32)-(16,36) = "else"
│ │ │ │ ├── statements: ∅ │ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (202...208) = "ensure" │ │ │ │ └── end_keyword_loc: (16,38)-(16,44) = "ensure"
│ │ │ ├── ensure_clause: │ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (202...213)) │ │ │ │ @ EnsureNode (location: (16,38)-(16,49))
│ │ │ │ ├── ensure_keyword_loc: (202...208) = "ensure" │ │ │ │ ├── ensure_keyword_loc: (16,38)-(16,44) = "ensure"
│ │ │ │ ├── statements: ∅ │ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (210...213) = "end" │ │ │ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ │ │ └── end_keyword_loc: (210...213) = "end" │ │ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ │ └── end_keyword_loc: (210...213) = "end" │ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ ├── end_keyword_loc: (215...218) = "end" │ ├── end_keyword_loc: (16,51)-(16,54) = "end"
│ └── name: :A │ └── name: :A
├── @ SingletonClassNode (location: (220...240)) ├── @ SingletonClassNode (location: (18,0)-(19,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (220...225) = "class" │ ├── class_keyword_loc: (18,0)-(18,5) = "class"
│ ├── operator_loc: (226...228) = "<<" │ ├── operator_loc: (18,6)-(18,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (229...236)) │ │ @ CallNode (location: (18,9)-(18,16))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (229...232)) │ │ │ @ CallNode (location: (18,9)-(18,12))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (229...232) = "foo" │ │ │ ├── message_loc: (18,9)-(18,12) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: (232...233) = "." │ │ ├── call_operator_loc: (18,12)-(18,13) = "."
│ │ ├── message_loc: (233...236) = "bar" │ │ ├── message_loc: (18,13)-(18,16) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -230,26 +230,26 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── body: ∅ │ ├── body: ∅
│ └── end_keyword_loc: (237...240) = "end" │ └── end_keyword_loc: (19,0)-(19,3) = "end"
├── @ SingletonClassNode (location: (242...262)) ├── @ SingletonClassNode (location: (21,0)-(21,20))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (242...247) = "class" │ ├── class_keyword_loc: (21,0)-(21,5) = "class"
│ ├── operator_loc: (248...250) = "<<" │ ├── operator_loc: (21,6)-(21,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (251...258)) │ │ @ CallNode (location: (21,9)-(21,16))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (251...254)) │ │ │ @ CallNode (location: (21,9)-(21,12))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (251...254) = "foo" │ │ │ ├── message_loc: (21,9)-(21,12) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: (254...255) = "." │ │ ├── call_operator_loc: (21,12)-(21,13) = "."
│ │ ├── message_loc: (255...258) = "bar" │ │ ├── message_loc: (21,13)-(21,16) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -257,99 +257,99 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── body: ∅ │ ├── body: ∅
│ └── end_keyword_loc: (259...262) = "end" │ └── end_keyword_loc: (21,17)-(21,20) = "end"
├── @ SingletonClassNode (location: (264...281)) ├── @ SingletonClassNode (location: (23,0)-(24,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (264...269) = "class" │ ├── class_keyword_loc: (23,0)-(23,5) = "class"
│ ├── operator_loc: (270...272) = "<<" │ ├── operator_loc: (23,6)-(23,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ SelfNode (location: (273...277)) │ │ @ SelfNode (location: (23,9)-(23,13))
│ ├── body: ∅ │ ├── body: ∅
│ └── end_keyword_loc: (278...281) = "end" │ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ SingletonClassNode (location: (283...300)) ├── @ SingletonClassNode (location: (26,0)-(26,17))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (283...288) = "class" │ ├── class_keyword_loc: (26,0)-(26,5) = "class"
│ ├── operator_loc: (289...291) = "<<" │ ├── operator_loc: (26,6)-(26,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ SelfNode (location: (292...296)) │ │ @ SelfNode (location: (26,9)-(26,13))
│ ├── body: ∅ │ ├── body: ∅
│ └── end_keyword_loc: (297...300) = "end" │ └── end_keyword_loc: (26,14)-(26,17) = "end"
├── @ SingletonClassNode (location: (302...325)) ├── @ SingletonClassNode (location: (28,0)-(30,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (302...307) = "class" │ ├── class_keyword_loc: (28,0)-(28,5) = "class"
│ ├── operator_loc: (308...310) = "<<" │ ├── operator_loc: (28,6)-(28,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ SelfNode (location: (311...315)) │ │ @ SelfNode (location: (28,9)-(28,13))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (316...321)) │ │ @ StatementsNode (location: (29,0)-(29,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (316...321)) │ │ └── @ CallNode (location: (29,0)-(29,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (316...317)) │ │ │ @ IntegerNode (location: (29,0)-(29,1))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (318...319) = "+" │ │ ├── message_loc: (29,2)-(29,3) = "+"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (320...321)) │ │ │ @ ArgumentsNode (location: (29,4)-(29,5))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (320...321)) │ │ │ └── @ IntegerNode (location: (29,4)-(29,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "+" │ │ └── name: "+"
│ └── end_keyword_loc: (322...325) = "end" │ └── end_keyword_loc: (30,0)-(30,3) = "end"
├── @ SingletonClassNode (location: (327...350)) ├── @ SingletonClassNode (location: (32,0)-(32,23))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (327...332) = "class" │ ├── class_keyword_loc: (32,0)-(32,5) = "class"
│ ├── operator_loc: (333...335) = "<<" │ ├── operator_loc: (32,6)-(32,8) = "<<"
│ ├── expression: │ ├── expression:
│ │ @ SelfNode (location: (336...340)) │ │ @ SelfNode (location: (32,9)-(32,13))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (341...346)) │ │ @ StatementsNode (location: (32,14)-(32,19))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (341...346)) │ │ └── @ CallNode (location: (32,14)-(32,19))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (341...342)) │ │ │ @ IntegerNode (location: (32,14)-(32,15))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (343...344) = "+" │ │ ├── message_loc: (32,16)-(32,17) = "+"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (345...346)) │ │ │ @ ArgumentsNode (location: (32,18)-(32,19))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (345...346)) │ │ │ └── @ IntegerNode (location: (32,18)-(32,19))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "+" │ │ └── name: "+"
│ └── end_keyword_loc: (347...350) = "end" │ └── end_keyword_loc: (32,20)-(32,23) = "end"
└── @ ClassNode (location: (352...370)) └── @ ClassNode (location: (34,0)-(35,3))
├── locals: [] ├── locals: []
├── class_keyword_loc: (352...357) = "class" ├── class_keyword_loc: (34,0)-(34,5) = "class"
├── constant_path: ├── constant_path:
│ @ ConstantReadNode (location: (358...359)) │ @ ConstantReadNode (location: (34,6)-(34,7))
│ └── name: :A │ └── name: :A
├── inheritance_operator_loc: (360...361) = "<" ├── inheritance_operator_loc: (34,8)-(34,9) = "<"
├── superclass: ├── superclass:
│ @ CallNode (location: (362...366)) │ @ CallNode (location: (34,10)-(34,14))
│ ├── receiver: │ ├── receiver:
│ │ @ ConstantReadNode (location: (362...363)) │ │ @ ConstantReadNode (location: (34,10)-(34,11))
│ │ └── name: :B │ │ └── name: :B
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (363...366) = "[1]" │ ├── message_loc: (34,11)-(34,14) = "[1]"
│ ├── opening_loc: (363...364) = "[" │ ├── opening_loc: (34,11)-(34,12) = "["
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (364...365)) │ │ @ ArgumentsNode (location: (34,12)-(34,13))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (364...365)) │ │ └── @ IntegerNode (location: (34,12)-(34,13))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: (365...366) = "]" │ ├── closing_loc: (34,13)-(34,14) = "]"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "[]" │ └── name: "[]"
├── body: ∅ ├── body: ∅
├── end_keyword_loc: (367...370) = "end" ├── end_keyword_loc: (35,0)-(35,3) = "end"
└── name: :A └── name: :A

70
test/yarp/snapshots/comments.txt
View file

@ -1,142 +1,142 @@
@ ProgramNode (location: (0...118)) @ ProgramNode (location: (1,0)-(24,5))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...118)) @ StatementsNode (location: (1,0)-(24,5))
└── body: (length: 9) └── body: (length: 9)
├── @ CallNode (location: (0...1)) ├── @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a" │ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "a" │ └── name: "a"
├── @ CallNode (location: (13...14)) ├── @ CallNode (location: (3,0)-(3,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (13...14) = "b" │ ├── message_loc: (3,0)-(3,1) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "b" │ └── name: "b"
├── @ CallNode (location: (16...17)) ├── @ CallNode (location: (5,0)-(5,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (16...17) = "c" │ ├── message_loc: (5,0)-(5,1) = "c"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "c" │ └── name: "c"
├── @ CallNode (location: (28...29)) ├── @ CallNode (location: (6,0)-(6,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (28...29) = "d" │ ├── message_loc: (6,0)-(6,1) = "d"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "d" │ └── name: "d"
├── @ CallNode (location: (31...47)) ├── @ CallNode (location: (8,0)-(10,4))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (31...32)) │ │ @ CallNode (location: (8,0)-(8,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (31...32) = "e" │ │ ├── message_loc: (8,0)-(8,1) = "e"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "e" │ │ └── name: "e"
│ ├── call_operator_loc: (45...46) = "." │ ├── call_operator_loc: (10,2)-(10,3) = "."
│ ├── message_loc: (46...47) = "f" │ ├── message_loc: (10,3)-(10,4) = "f"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "f" │ └── name: "f"
├── @ CallNode (location: (49...64)) ├── @ CallNode (location: (12,0)-(14,2))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (49...50)) │ │ @ CallNode (location: (12,0)-(12,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (49...50) = "g" │ │ ├── message_loc: (12,0)-(12,1) = "g"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "g" │ │ └── name: "g"
│ ├── call_operator_loc: (62...63) = "." │ ├── call_operator_loc: (14,0)-(14,1) = "."
│ ├── message_loc: (63...64) = "h" │ ├── message_loc: (14,1)-(14,2) = "h"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "h" │ └── name: "h"
├── @ CallNode (location: (66...80)) ├── @ CallNode (location: (16,0)-(17,2))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (66...67)) │ │ @ CallNode (location: (16,0)-(16,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (66...67) = "i" │ │ ├── message_loc: (16,0)-(16,1) = "i"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "i" │ │ └── name: "i"
│ ├── call_operator_loc: (78...79) = "." │ ├── call_operator_loc: (17,0)-(17,1) = "."
│ ├── message_loc: (79...80) = "j" │ ├── message_loc: (17,1)-(17,2) = "j"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "j" │ └── name: "j"
├── @ CallNode (location: (82...98)) ├── @ CallNode (location: (19,0)-(20,4))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (82...83)) │ │ @ CallNode (location: (19,0)-(19,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (82...83) = "k" │ │ ├── message_loc: (19,0)-(19,1) = "k"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "k" │ │ └── name: "k"
│ ├── call_operator_loc: (96...97) = "." │ ├── call_operator_loc: (20,2)-(20,3) = "."
│ ├── message_loc: (97...98) = "l" │ ├── message_loc: (20,3)-(20,4) = "l"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "l" │ └── name: "l"
└── @ CallNode (location: (100...118)) └── @ CallNode (location: (22,0)-(24,5))
├── receiver: ├── receiver:
│ @ CallNode (location: (100...101)) │ @ CallNode (location: (22,0)-(22,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (100...101) = "m" │ ├── message_loc: (22,0)-(22,1) = "m"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "m" │ └── name: "m"
├── call_operator_loc: (115...117) = "&." ├── call_operator_loc: (24,2)-(24,4) = "&."
├── message_loc: (117...118) = "n" ├── message_loc: (24,4)-(24,5) = "n"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

850
test/yarp/snapshots/constants.txt
View file

File diff suppressed because it is too large Load diff

236
test/yarp/snapshots/dash_heredocs.txt
View file

@ -1,250 +1,250 @@
@ ProgramNode (location: (0...278)) @ ProgramNode (location: (1,0)-(57,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...278)) @ StatementsNode (location: (1,0)-(57,11))
└── body: (length: 13) └── body: (length: 13)
├── @ StringNode (location: (0...6)) ├── @ StringNode (location: (1,0)-(1,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (0...6) = "<<-EOF" │ ├── opening_loc: (1,0)-(1,6) = "<<-EOF"
│ ├── content_loc: (7...11) = " a\n" │ ├── content_loc: (2,0)-(2,0) = " a\n"
│ ├── closing_loc: (11...15) = "EOF\n" │ ├── closing_loc: (3,0)-(3,0) = "EOF\n"
│ └── unescaped: " a\n" │ └── unescaped: " a\n"
├── @ CallNode (location: (16...36)) ├── @ CallNode (location: (5,0)-(5,20))
│ ├── receiver: │ ├── receiver:
│ │ @ StringNode (location: (16...24)) │ │ @ StringNode (location: (5,0)-(5,8))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (16...24) = "<<-FIRST" │ │ ├── opening_loc: (5,0)-(5,8) = "<<-FIRST"
│ │ ├── content_loc: (37...41) = " a\n" │ │ ├── content_loc: (6,0)-(6,0) = " a\n"
│ │ ├── closing_loc: (41...47) = "FIRST\n" │ │ ├── closing_loc: (7,0)-(7,0) = "FIRST\n"
│ │ └── unescaped: " a\n" │ │ └── unescaped: " a\n"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (25...26) = "+" │ ├── message_loc: (5,9)-(5,10) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (27...36)) │ │ @ ArgumentsNode (location: (5,11)-(5,20))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ StringNode (location: (27...36)) │ │ └── @ StringNode (location: (5,11)-(5,20))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (27...36) = "<<-SECOND" │ │ ├── opening_loc: (5,11)-(5,20) = "<<-SECOND"
│ │ ├── content_loc: (47...51) = " b\n" │ │ ├── content_loc: (8,0)-(8,0) = " b\n"
│ │ ├── closing_loc: (51...58) = "SECOND\n" │ │ ├── closing_loc: (9,0)-(9,0) = "SECOND\n"
│ │ └── unescaped: " b\n" │ │ └── unescaped: " b\n"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
├── @ InterpolatedXStringNode (location: (59...67)) ├── @ InterpolatedXStringNode (location: (11,0)-(11,8))
│ ├── opening_loc: (59...67) = "<<-`EOF`" │ ├── opening_loc: (11,0)-(11,8) = "<<-`EOF`"
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (68...72)) │ │ ├── @ StringNode (location: (12,0)-(12,0))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (68...72) = " a\n" │ │ │ ├── content_loc: (12,0)-(12,0) = " a\n"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n" │ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (72...76)) │ │ ├── @ EmbeddedStatementsNode (location: (13,0)-(13,4))
│ │ │ ├── opening_loc: (72...74) = "\#{" │ │ │ ├── opening_loc: (13,0)-(13,2) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (74...75)) │ │ │ │ @ StatementsNode (location: (13,2)-(13,3))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (74...75)) │ │ │ │ └── @ CallNode (location: (13,2)-(13,3))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (74...75) = "b" │ │ │ │ ├── message_loc: (13,2)-(13,3) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (75...76) = "}" │ │ │ └── closing_loc: (13,3)-(13,4) = "}"
│ │ └── @ StringNode (location: (76...77)) │ │ └── @ StringNode (location: (13,4)-(13,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (76...77) = "\n" │ │ ├── content_loc: (13,4)-(13,0) = "\n"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n" │ │ └── unescaped: "\n"
│ └── closing_loc: (77...81) = "EOF\n" │ └── closing_loc: (14,0)-(14,0) = "EOF\n"
├── @ StringNode (location: (82...88)) ├── @ StringNode (location: (16,0)-(16,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (82...88) = "<<-EOF" │ ├── opening_loc: (16,0)-(16,6) = "<<-EOF"
│ ├── content_loc: (98...102) = " a\n" │ ├── content_loc: (17,0)-(17,0) = " a\n"
│ ├── closing_loc: (102...106) = "EOF\n" │ ├── closing_loc: (18,0)-(18,0) = "EOF\n"
│ └── unescaped: " a\n" │ └── unescaped: " a\n"
├── @ StringNode (location: (107...113)) ├── @ StringNode (location: (20,0)-(20,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (107...113) = "<<-EOF" │ ├── opening_loc: (20,0)-(20,6) = "<<-EOF"
│ ├── content_loc: (114...122) = " a\n b\n" │ ├── content_loc: (21,0)-(22,0) = " a\n b\n"
│ ├── closing_loc: (122...128) = " EOF\n" │ ├── closing_loc: (23,0)-(23,0) = " EOF\n"
│ └── unescaped: " a\n b\n" │ └── unescaped: " a\n b\n"
├── @ InterpolatedStringNode (location: (129...137)) ├── @ InterpolatedStringNode (location: (25,0)-(25,8))
│ ├── opening_loc: (129...137) = "<<-\"EOF\"" │ ├── opening_loc: (25,0)-(25,8) = "<<-\"EOF\""
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (138...142)) │ │ ├── @ StringNode (location: (26,0)-(26,0))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (138...142) = " a\n" │ │ │ ├── content_loc: (26,0)-(26,0) = " a\n"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n" │ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (142...146)) │ │ ├── @ EmbeddedStatementsNode (location: (27,0)-(27,4))
│ │ │ ├── opening_loc: (142...144) = "\#{" │ │ │ ├── opening_loc: (27,0)-(27,2) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (144...145)) │ │ │ │ @ StatementsNode (location: (27,2)-(27,3))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (144...145)) │ │ │ │ └── @ CallNode (location: (27,2)-(27,3))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (144...145) = "b" │ │ │ │ ├── message_loc: (27,2)-(27,3) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (145...146) = "}" │ │ │ └── closing_loc: (27,3)-(27,4) = "}"
│ │ └── @ StringNode (location: (146...147)) │ │ └── @ StringNode (location: (27,4)-(27,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (146...147) = "\n" │ │ ├── content_loc: (27,4)-(27,0) = "\n"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n" │ │ └── unescaped: "\n"
│ └── closing_loc: (147...151) = "EOF\n" │ └── closing_loc: (28,0)-(28,0) = "EOF\n"
├── @ InterpolatedStringNode (location: (152...158)) ├── @ InterpolatedStringNode (location: (30,0)-(30,6))
│ ├── opening_loc: (152...158) = "<<-EOF" │ ├── opening_loc: (30,0)-(30,6) = "<<-EOF"
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (159...163)) │ │ ├── @ StringNode (location: (31,0)-(31,0))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (159...163) = " a\n" │ │ │ ├── content_loc: (31,0)-(31,0) = " a\n"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n" │ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (163...167)) │ │ ├── @ EmbeddedStatementsNode (location: (32,0)-(32,4))
│ │ │ ├── opening_loc: (163...165) = "\#{" │ │ │ ├── opening_loc: (32,0)-(32,2) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (165...166)) │ │ │ │ @ StatementsNode (location: (32,2)-(32,3))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (165...166)) │ │ │ │ └── @ CallNode (location: (32,2)-(32,3))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (165...166) = "b" │ │ │ │ ├── message_loc: (32,2)-(32,3) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (166...167) = "}" │ │ │ └── closing_loc: (32,3)-(32,4) = "}"
│ │ └── @ StringNode (location: (167...168)) │ │ └── @ StringNode (location: (32,4)-(32,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (167...168) = "\n" │ │ ├── content_loc: (32,4)-(32,0) = "\n"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n" │ │ └── unescaped: "\n"
│ └── closing_loc: (168...172) = "EOF\n" │ └── closing_loc: (33,0)-(33,0) = "EOF\n"
├── @ StringNode (location: (173...179)) ├── @ StringNode (location: (35,0)-(35,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (173...175) = "%#" │ ├── opening_loc: (35,0)-(35,2) = "%#"
│ ├── content_loc: (175...178) = "abc" │ ├── content_loc: (35,2)-(35,5) = "abc"
│ ├── closing_loc: (178...179) = "#" │ ├── closing_loc: (35,5)-(35,6) = "#"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (181...187)) ├── @ StringNode (location: (37,0)-(37,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (181...187) = "<<-EOF" │ ├── opening_loc: (37,0)-(37,6) = "<<-EOF"
│ ├── content_loc: (188...196) = " a\n b\n" │ ├── content_loc: (38,0)-(39,0) = " a\n b\n"
│ ├── closing_loc: (196...200) = "EOF\n" │ ├── closing_loc: (40,0)-(40,0) = "EOF\n"
│ └── unescaped: " a\n b\n" │ └── unescaped: " a\n b\n"
├── @ StringNode (location: (201...206)) ├── @ StringNode (location: (42,0)-(42,5))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (201...206) = "<<-''" │ ├── opening_loc: (42,0)-(42,5) = "<<-''"
│ ├── content_loc: (207...207) = "" │ ├── content_loc: (43,0)-(42,0) = ""
│ ├── closing_loc: (207...208) = "\n" │ ├── closing_loc: (43,0)-(43,0) = "\n"
│ └── unescaped: "" │ └── unescaped: ""
├── @ StringNode (location: (209...217)) ├── @ StringNode (location: (45,0)-(45,8))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (209...217) = "<<-'EOF'" │ ├── opening_loc: (45,0)-(45,8) = "<<-'EOF'"
│ ├── content_loc: (218...227) = " a \#{1}\n" │ ├── content_loc: (46,0)-(46,0) = " a \#{1}\n"
│ ├── closing_loc: (227...231) = "EOF\n" │ ├── closing_loc: (47,0)-(47,0) = "EOF\n"
│ └── unescaped: " a \#{1}\n" │ └── unescaped: " a \#{1}\n"
├── @ CallNode (location: (232...243)) ├── @ CallNode (location: (49,0)-(49,11))
│ ├── receiver: │ ├── receiver:
│ │ @ StringNode (location: (232...236)) │ │ @ StringNode (location: (49,0)-(49,4))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (232...236) = "<<-A" │ │ ├── opening_loc: (49,0)-(49,4) = "<<-A"
│ │ ├── content_loc: (244...248) = " a\n" │ │ ├── content_loc: (50,0)-(50,0) = " a\n"
│ │ ├── closing_loc: (248...250) = "A\n" │ │ ├── closing_loc: (51,0)-(51,0) = "A\n"
│ │ └── unescaped: " a\n" │ │ └── unescaped: " a\n"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (237...238) = "+" │ ├── message_loc: (49,5)-(49,6) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (239...243)) │ │ @ ArgumentsNode (location: (49,7)-(49,11))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ InterpolatedStringNode (location: (239...243)) │ │ └── @ InterpolatedStringNode (location: (49,7)-(49,11))
│ │ ├── opening_loc: (239...243) = "<<-B" │ │ ├── opening_loc: (49,7)-(49,11) = "<<-B"
│ │ ├── parts: (length: 3) │ │ ├── parts: (length: 3)
│ │ │ ├── @ StringNode (location: (250...256)) │ │ │ ├── @ StringNode (location: (52,0)-(53,2))
│ │ │ │ ├── flags: ∅ │ │ │ │ ├── flags: ∅
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── content_loc: (250...256) = " b\n " │ │ │ │ ├── content_loc: (52,0)-(53,2) = " b\n "
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: " b\n " │ │ │ │ └── unescaped: " b\n "
│ │ │ ├── @ EmbeddedStatementsNode (location: (256...263)) │ │ │ ├── @ EmbeddedStatementsNode (location: (53,2)-(54,3))
│ │ │ │ ├── opening_loc: (256...258) = "\#{" │ │ │ │ ├── opening_loc: (53,2)-(53,4) = "\#{"
│ │ │ │ ├── statements: │ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (258...259)) │ │ │ │ │ @ StatementsNode (location: (53,4)-(53,5))
│ │ │ │ │ └── body: (length: 1) │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (258...259)) │ │ │ │ │ └── @ IntegerNode (location: (53,4)-(53,5))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ └── closing_loc: (262...263) = "}" │ │ │ │ └── closing_loc: (54,2)-(54,3) = "}"
│ │ │ └── @ StringNode (location: (263...264)) │ │ │ └── @ StringNode (location: (54,3)-(54,0))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (263...264) = "\n" │ │ │ ├── content_loc: (54,3)-(54,0) = "\n"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "\n" │ │ │ └── unescaped: "\n"
│ │ └── closing_loc: (264...266) = "B\n" │ │ └── closing_loc: (55,0)-(55,0) = "B\n"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
└── @ CallNode (location: (267...278)) └── @ CallNode (location: (57,0)-(57,11))
├── receiver: ├── receiver:
│ @ StringNode (location: (267...271)) │ @ StringNode (location: (57,0)-(57,4))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (267...271) = "<<-A" │ ├── opening_loc: (57,0)-(57,4) = "<<-A"
│ ├── content_loc: (279...283) = " a\n" │ ├── content_loc: (58,0)-(58,0) = " a\n"
│ ├── closing_loc: (283...285) = "A\n" │ ├── closing_loc: (59,0)-(59,0) = "A\n"
│ └── unescaped: " a\n" │ └── unescaped: " a\n"
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (272...273) = "+" ├── message_loc: (57,5)-(57,6) = "+"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (274...278)) │ @ ArgumentsNode (location: (57,7)-(57,11))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ InterpolatedStringNode (location: (274...278)) │ └── @ InterpolatedStringNode (location: (57,7)-(57,11))
│ ├── opening_loc: (274...278) = "<<-B" │ ├── opening_loc: (57,7)-(57,11) = "<<-B"
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (285...291)) │ │ ├── @ StringNode (location: (60,0)-(61,2))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (285...291) = " b\n " │ │ │ ├── content_loc: (60,0)-(61,2) = " b\n "
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " b\n " │ │ │ └── unescaped: " b\n "
│ │ ├── @ EmbeddedStatementsNode (location: (291...298)) │ │ ├── @ EmbeddedStatementsNode (location: (61,2)-(62,4))
│ │ │ ├── opening_loc: (291...293) = "\#{" │ │ │ ├── opening_loc: (61,2)-(61,4) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (296...297)) │ │ │ │ @ StatementsNode (location: (62,2)-(62,3))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (296...297)) │ │ │ │ └── @ IntegerNode (location: (62,2)-(62,3))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── closing_loc: (297...298) = "}" │ │ │ └── closing_loc: (62,3)-(62,4) = "}"
│ │ └── @ StringNode (location: (298...299)) │ │ └── @ StringNode (location: (62,4)-(62,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (298...299) = "\n" │ │ ├── content_loc: (62,4)-(62,0) = "\n"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n" │ │ └── unescaped: "\n"
│ └── closing_loc: (299...301) = "B\n" │ └── closing_loc: (63,0)-(63,0) = "B\n"
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅

62
test/yarp/snapshots/defined.txt
View file

@ -1,49 +1,49 @@
@ ProgramNode (location: (0...78)) @ ProgramNode (location: (1,0)-(7,10))
├── locals: [:x] ├── locals: [:x]
└── statements: └── statements:
@ StatementsNode (location: (0...78)) @ StatementsNode (location: (1,0)-(7,10))
└── body: (length: 4) └── body: (length: 4)
├── @ AndNode (location: (0...25)) ├── @ AndNode (location: (1,0)-(1,25))
│ ├── left: │ ├── left:
│ │ @ DefinedNode (location: (0...10)) │ │ @ DefinedNode (location: (1,0)-(1,10))
│ │ ├── lparen_loc: ∅ │ │ ├── lparen_loc: ∅
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (9...10)) │ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── rparen_loc: ∅ │ │ ├── rparen_loc: ∅
│ │ └── keyword_loc: (0...8) = "defined?" │ │ └── keyword_loc: (1,0)-(1,8) = "defined?"
│ ├── right: │ ├── right:
│ │ @ DefinedNode (location: (15...25)) │ │ @ DefinedNode (location: (1,15)-(1,25))
│ │ ├── lparen_loc: ∅ │ │ ├── lparen_loc: ∅
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (24...25)) │ │ │ @ IntegerNode (location: (1,24)-(1,25))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── rparen_loc: ∅ │ │ ├── rparen_loc: ∅
│ │ └── keyword_loc: (15...23) = "defined?" │ │ └── keyword_loc: (1,15)-(1,23) = "defined?"
│ └── operator_loc: (11...14) = "and" │ └── operator_loc: (1,11)-(1,14) = "and"
├── @ DefinedNode (location: (27...43)) ├── @ DefinedNode (location: (3,0)-(3,16))
│ ├── lparen_loc: (35...36) = "(" │ ├── lparen_loc: (3,8)-(3,9) = "("
│ ├── value: │ ├── value:
│ │ @ LocalVariableOperatorWriteNode (location: (36...42)) │ │ @ LocalVariableOperatorWriteNode (location: (3,9)-(3,15))
│ │ ├── name_loc: (36...37) = "x" │ │ ├── name_loc: (3,9)-(3,10) = "x"
│ │ ├── operator_loc: (38...40) = "%=" │ │ ├── operator_loc: (3,11)-(3,13) = "%="
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (41...42)) │ │ │ @ IntegerNode (location: (3,14)-(3,15))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── name: :x │ │ ├── name: :x
│ │ ├── operator: :% │ │ ├── operator: :%
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── rparen_loc: (42...43) = ")" │ ├── rparen_loc: (3,15)-(3,16) = ")"
│ └── keyword_loc: (27...35) = "defined?" │ └── keyword_loc: (3,0)-(3,8) = "defined?"
├── @ DefinedNode (location: (45...66)) ├── @ DefinedNode (location: (5,0)-(5,21))
│ ├── lparen_loc: (53...54) = "(" │ ├── lparen_loc: (5,8)-(5,9) = "("
│ ├── value: │ ├── value:
│ │ @ AndNode (location: (54...65)) │ │ @ AndNode (location: (5,9)-(5,20))
│ │ ├── left: │ │ ├── left:
│ │ │ @ CallNode (location: (54...57)) │ │ │ @ CallNode (location: (5,9)-(5,12))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (54...57) = "foo" │ │ │ ├── message_loc: (5,9)-(5,12) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -51,23 +51,23 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── right: │ │ ├── right:
│ │ │ @ CallNode (location: (62...65)) │ │ │ @ CallNode (location: (5,17)-(5,20))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (62...65) = "bar" │ │ │ ├── message_loc: (5,17)-(5,20) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ └── operator_loc: (58...61) = "and" │ │ └── operator_loc: (5,13)-(5,16) = "and"
│ ├── rparen_loc: (65...66) = ")" │ ├── rparen_loc: (5,20)-(5,21) = ")"
│ └── keyword_loc: (45...53) = "defined?" │ └── keyword_loc: (5,0)-(5,8) = "defined?"
└── @ DefinedNode (location: (68...78)) └── @ DefinedNode (location: (7,0)-(7,10))
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── value: ├── value:
│ @ IntegerNode (location: (77...78)) │ @ IntegerNode (location: (7,9)-(7,10))
│ └── flags: decimal │ └── flags: decimal
├── rparen_loc: ∅ ├── rparen_loc: ∅
└── keyword_loc: (68...76) = "defined?" └── keyword_loc: (7,0)-(7,8) = "defined?"

90
test/yarp/snapshots/dos_endings.txt
View file

@ -1,93 +1,93 @@
@ ProgramNode (location: (0...108)) @ ProgramNode (location: (1,0)-(17,20))
├── locals: [:x, :a] ├── locals: [:x, :a]
└── statements: └── statements:
@ StatementsNode (location: (0...108)) @ StatementsNode (location: (1,0)-(17,20))
└── body: (length: 5) └── body: (length: 5)
├── @ CallNode (location: (0...24)) ├── @ CallNode (location: (1,0)-(2,12))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...4) = "puts" │ ├── message_loc: (1,0)-(1,4) = "puts"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (5...24)) │ │ @ ArgumentsNode (location: (1,5)-(2,12))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ StringConcatNode (location: (5...24)) │ │ └── @ StringConcatNode (location: (1,5)-(2,12))
│ │ ├── left: │ │ ├── left:
│ │ │ @ StringNode (location: (5...9)) │ │ │ @ StringNode (location: (1,5)-(1,9))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (5...6) = "\"" │ │ │ ├── opening_loc: (1,5)-(1,6) = "\""
│ │ │ ├── content_loc: (6...8) = "hi" │ │ │ ├── content_loc: (1,6)-(1,8) = "hi"
│ │ │ ├── closing_loc: (8...9) = "\"" │ │ │ ├── closing_loc: (1,8)-(1,9) = "\""
│ │ │ └── unescaped: "hi" │ │ │ └── unescaped: "hi"
│ │ └── right: │ │ └── right:
│ │ @ StringNode (location: (17...24)) │ │ @ StringNode (location: (2,5)-(2,12))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (17...18) = "\"" │ │ ├── opening_loc: (2,5)-(2,6) = "\""
│ │ ├── content_loc: (18...23) = "there" │ │ ├── content_loc: (2,6)-(2,11) = "there"
│ │ ├── closing_loc: (23...24) = "\"" │ │ ├── closing_loc: (2,11)-(2,12) = "\""
│ │ └── unescaped: "there" │ │ └── unescaped: "there"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "puts" │ └── name: "puts"
├── @ ArrayNode (location: (28...37)) ├── @ ArrayNode (location: (4,0)-(5,2))
│ ├── elements: (length: 1) │ ├── elements: (length: 1)
│ │ └── @ SymbolNode (location: (31...36)) │ │ └── @ SymbolNode (location: (4,3)-(5,1))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (31...36) = "a\\\r\nb" │ │ ├── value_loc: (4,3)-(5,1) = "a\\\r\nb"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "ab" │ │ └── unescaped: "ab"
│ ├── opening_loc: (28...31) = "%I{" │ ├── opening_loc: (4,0)-(4,3) = "%I{"
│ └── closing_loc: (36...37) = "}" │ └── closing_loc: (5,1)-(5,2) = "}"
├── @ StringNode (location: (41...45)) ├── @ StringNode (location: (7,0)-(7,4))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (41...45) = "<<-E" │ ├── opening_loc: (7,0)-(7,4) = "<<-E"
│ ├── content_loc: (47...70) = " 1 \\\r\n 2\r\n 3\r\n" │ ├── content_loc: (8,0)-(10,0) = " 1 \\\r\n 2\r\n 3\r\n"
│ ├── closing_loc: (70...73) = "E\r\n" │ ├── closing_loc: (11,0)-(11,0) = "E\r\n"
│ └── unescaped: " 1 2\r\n 3\r\n" │ └── unescaped: " 1 2\r\n 3\r\n"
├── @ LocalVariableWriteNode (location: (75...84)) ├── @ LocalVariableWriteNode (location: (13,0)-(14,0))
│ ├── name: :x │ ├── name: :x
│ ├── depth: 0 │ ├── depth: 0
│ ├── name_loc: (75...76) = "x" │ ├── name_loc: (13,0)-(13,1) = "x"
│ ├── value: │ ├── value:
│ │ @ StringNode (location: (79...84)) │ │ @ StringNode (location: (13,4)-(14,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (79...82) = "%\r\n" │ │ ├── opening_loc: (13,4)-(13,0) = "%\r\n"
│ │ ├── content_loc: (82...82) = "" │ │ ├── content_loc: (14,0)-(13,0) = ""
│ │ ├── closing_loc: (82...84) = "\r\n" │ │ ├── closing_loc: (14,0)-(14,0) = "\r\n"
│ │ └── unescaped: "" │ │ └── unescaped: ""
│ └── operator_loc: (77...78) = "=" │ └── operator_loc: (13,2)-(13,3) = "="
└── @ LocalVariableWriteNode (location: (88...108)) └── @ LocalVariableWriteNode (location: (17,0)-(17,20))
├── name: :a ├── name: :a
├── depth: 0 ├── depth: 0
├── name_loc: (88...89) = "a" ├── name_loc: (17,0)-(17,1) = "a"
├── value: ├── value:
│ @ CallNode (location: (92...108)) │ @ CallNode (location: (17,4)-(17,20))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (92...95) = "foo" │ ├── message_loc: (17,4)-(17,7) = "foo"
│ ├── opening_loc: (95...96) = "(" │ ├── opening_loc: (17,7)-(17,8) = "("
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (96...107)) │ │ @ ArgumentsNode (location: (17,8)-(17,19))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (96...107)) │ │ └── @ CallNode (location: (17,8)-(17,19))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ StringNode (location: (96...102)) │ │ │ @ StringNode (location: (17,8)-(17,14))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (96...102) = "<<~EOF" │ │ │ ├── opening_loc: (17,8)-(17,14) = "<<~EOF"
│ │ │ ├── content_loc: (110...121) = "\r\n baz\r\n" │ │ │ ├── content_loc: (18,0)-(19,0) = "\r\n baz\r\n"
│ │ │ ├── closing_loc: (121...128) = " EOF\r\n" │ │ │ ├── closing_loc: (20,0)-(20,0) = " EOF\r\n"
│ │ │ └── unescaped: "\nbaz\r\n" │ │ │ └── unescaped: "\nbaz\r\n"
│ │ ├── call_operator_loc: (102...103) = "." │ │ ├── call_operator_loc: (17,14)-(17,15) = "."
│ │ ├── message_loc: (103...107) = "chop" │ │ ├── message_loc: (17,15)-(17,19) = "chop"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "chop" │ │ └── name: "chop"
│ ├── closing_loc: (107...108) = ")" │ ├── closing_loc: (17,19)-(17,20) = ")"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
└── operator_loc: (90...91) = "=" └── operator_loc: (17,2)-(17,3) = "="

4
test/yarp/snapshots/embdoc_no_newline_at_end.txt
View file

@ -1,5 +1,5 @@
@ ProgramNode (location: (0...0)) @ ProgramNode (location: (1,0)-(0,0))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...0)) @ StatementsNode (location: (1,0)-(0,0))
└── body: (length: 0) └── body: (length: 0)

68
test/yarp/snapshots/endless_methods.txt
View file

@ -1,100 +1,100 @@
@ ProgramNode (location: (0...51)) @ ProgramNode (location: (1,0)-(5,22))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...51)) @ StatementsNode (location: (1,0)-(5,22))
└── body: (length: 3) └── body: (length: 3)
├── @ DefNode (location: (0...11)) ├── @ DefNode (location: (1,0)-(1,11))
│ ├── name: :foo │ ├── name: :foo
│ ├── name_loc: (4...7) = "foo" │ ├── name_loc: (1,4)-(1,7) = "foo"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (10...11)) │ │ @ StatementsNode (location: (1,10)-(1,11))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (10...11)) │ │ └── @ IntegerNode (location: (1,10)-(1,11))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def" │ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: (8...9) = "=" │ ├── equal_loc: (1,8)-(1,9) = "="
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ DefNode (location: (13...27)) ├── @ DefNode (location: (3,0)-(3,14))
│ ├── name: :bar │ ├── name: :bar
│ ├── name_loc: (17...20) = "bar" │ ├── name_loc: (3,4)-(3,7) = "bar"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (23...27)) │ │ @ StatementsNode (location: (3,10)-(3,14))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (23...27)) │ │ └── @ CallNode (location: (3,10)-(3,14))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (23...24) = "A" │ │ ├── message_loc: (3,10)-(3,11) = "A"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (25...27)) │ │ │ @ ArgumentsNode (location: (3,12)-(3,14))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ StringNode (location: (25...27)) │ │ │ └── @ StringNode (location: (3,12)-(3,14))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (25...26) = "\"" │ │ │ ├── opening_loc: (3,12)-(3,13) = "\""
│ │ │ ├── content_loc: (26...26) = "" │ │ │ ├── content_loc: (3,13)-(3,13) = ""
│ │ │ ├── closing_loc: (26...27) = "\"" │ │ │ ├── closing_loc: (3,13)-(3,14) = "\""
│ │ │ └── unescaped: "" │ │ │ └── unescaped: ""
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "A" │ │ └── name: "A"
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (13...16) = "def" │ ├── def_keyword_loc: (3,0)-(3,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: (21...22) = "=" │ ├── equal_loc: (3,8)-(3,9) = "="
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
└── @ DefNode (location: (29...51)) └── @ DefNode (location: (5,0)-(5,22))
├── name: :method ├── name: :method
├── name_loc: (33...39) = "method" ├── name_loc: (5,4)-(5,10) = "method"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ∅ ├── parameters: ∅
├── body: ├── body:
│ @ StatementsNode (location: (42...51)) │ @ StatementsNode (location: (5,13)-(5,22))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (42...51)) │ └── @ CallNode (location: (5,13)-(5,22))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (42...47)) │ │ @ CallNode (location: (5,13)-(5,18))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (42...43)) │ │ │ @ IntegerNode (location: (5,13)-(5,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (44...45) = "+" │ │ ├── message_loc: (5,15)-(5,16) = "+"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (46...47)) │ │ │ @ ArgumentsNode (location: (5,17)-(5,18))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (46...47)) │ │ │ └── @ IntegerNode (location: (5,17)-(5,18))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "+" │ │ └── name: "+"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (48...49) = "+" │ ├── message_loc: (5,19)-(5,20) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (50...51)) │ │ @ ArgumentsNode (location: (5,21)-(5,22))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (50...51)) │ │ └── @ IntegerNode (location: (5,21)-(5,22))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
├── locals: [] ├── locals: []
├── def_keyword_loc: (29...32) = "def" ├── def_keyword_loc: (5,0)-(5,3) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── rparen_loc: ∅ ├── rparen_loc: ∅
├── equal_loc: (40...41) = "=" ├── equal_loc: (5,11)-(5,12) = "="
└── end_keyword_loc: ∅ └── end_keyword_loc: ∅

42
test/yarp/snapshots/endless_range_in_conditional.txt
View file

@ -1,46 +1,46 @@
@ ProgramNode (location: (0...39)) @ ProgramNode (location: (1,0)-(3,12))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...39)) @ StatementsNode (location: (1,0)-(3,12))
└── body: (length: 3) └── body: (length: 3)
├── @ IfNode (location: (0...13)) ├── @ IfNode (location: (1,0)-(1,13))
│ ├── if_keyword_loc: (0...2) = "if" │ ├── if_keyword_loc: (1,0)-(1,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ FlipFlopNode (location: (3...7)) │ │ @ FlipFlopNode (location: (1,3)-(1,7))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (3...4)) │ │ │ @ IntegerNode (location: (1,3)-(1,4))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (6...7)) │ │ │ @ IntegerNode (location: (1,6)-(1,7))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (4...6) = ".." │ │ ├── operator_loc: (1,4)-(1,6) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: ∅ │ ├── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (10...13) = "end" │ └── end_keyword_loc: (1,10)-(1,13) = "end"
├── @ IfNode (location: (14...26)) ├── @ IfNode (location: (2,0)-(2,12))
│ ├── if_keyword_loc: (14...16) = "if" │ ├── if_keyword_loc: (2,0)-(2,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ FlipFlopNode (location: (17...20)) │ │ @ FlipFlopNode (location: (2,3)-(2,6))
│ │ ├── left: ∅ │ │ ├── left: ∅
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (19...20)) │ │ │ @ IntegerNode (location: (2,5)-(2,6))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (17...19) = ".." │ │ ├── operator_loc: (2,3)-(2,5) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: ∅ │ ├── statements: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (23...26) = "end" │ └── end_keyword_loc: (2,9)-(2,12) = "end"
└── @ IfNode (location: (27...39)) └── @ IfNode (location: (3,0)-(3,12))
├── if_keyword_loc: (27...29) = "if" ├── if_keyword_loc: (3,0)-(3,2) = "if"
├── predicate: ├── predicate:
│ @ FlipFlopNode (location: (30...33)) │ @ FlipFlopNode (location: (3,3)-(3,6))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (30...31)) │ │ @ IntegerNode (location: (3,3)-(3,4))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: ∅ │ ├── right: ∅
│ ├── operator_loc: (31...33) = ".." │ ├── operator_loc: (3,4)-(3,6) = ".."
│ └── flags: ∅ │ └── flags: ∅
├── statements: ∅ ├── statements: ∅
├── consequent: ∅ ├── consequent: ∅
└── end_keyword_loc: (36...39) = "end" └── end_keyword_loc: (3,9)-(3,12) = "end"

148
test/yarp/snapshots/for.txt
View file

@ -1,172 +1,172 @@
@ ProgramNode (location: (0...143)) @ ProgramNode (location: (1,0)-(19,22))
├── locals: [:i, :j, :k] ├── locals: [:i, :j, :k]
└── statements: └── statements:
@ StatementsNode (location: (0...143)) @ StatementsNode (location: (1,0)-(19,22))
└── body: (length: 6) └── body: (length: 6)
├── @ ForNode (location: (0...20)) ├── @ ForNode (location: (1,0)-(3,3))
│ ├── index: │ ├── index:
│ │ @ LocalVariableTargetNode (location: (4...5)) │ │ @ LocalVariableTargetNode (location: (1,4)-(1,5))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── collection: │ ├── collection:
│ │ @ RangeNode (location: (9...14)) │ │ @ RangeNode (location: (1,9)-(1,14))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (9...10)) │ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (12...14)) │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (10...12) = ".." │ │ ├── operator_loc: (1,10)-(1,12) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (15...16)) │ │ @ StatementsNode (location: (2,0)-(2,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (15...16)) │ │ └── @ LocalVariableReadNode (location: (2,0)-(2,1))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── for_keyword_loc: (0...3) = "for" │ ├── for_keyword_loc: (1,0)-(1,3) = "for"
│ ├── in_keyword_loc: (6...8) = "in" │ ├── in_keyword_loc: (1,6)-(1,8) = "in"
│ ├── do_keyword_loc: ∅ │ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (17...20) = "end" │ └── end_keyword_loc: (3,0)-(3,3) = "end"
├── @ ForNode (location: (22...44)) ├── @ ForNode (location: (5,0)-(5,22))
│ ├── index: │ ├── index:
│ │ @ LocalVariableTargetNode (location: (26...27)) │ │ @ LocalVariableTargetNode (location: (5,4)-(5,5))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── collection: │ ├── collection:
│ │ @ RangeNode (location: (31...36)) │ │ @ RangeNode (location: (5,9)-(5,14))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (31...32)) │ │ │ @ IntegerNode (location: (5,9)-(5,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (34...36)) │ │ │ @ IntegerNode (location: (5,12)-(5,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (32...34) = ".." │ │ ├── operator_loc: (5,10)-(5,12) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (38...39)) │ │ @ StatementsNode (location: (5,16)-(5,17))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (38...39)) │ │ └── @ LocalVariableReadNode (location: (5,16)-(5,17))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── for_keyword_loc: (22...25) = "for" │ ├── for_keyword_loc: (5,0)-(5,3) = "for"
│ ├── in_keyword_loc: (28...30) = "in" │ ├── in_keyword_loc: (5,6)-(5,8) = "in"
│ ├── do_keyword_loc: ∅ │ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (41...44) = "end" │ └── end_keyword_loc: (5,19)-(5,22) = "end"
├── @ ForNode (location: (46...68)) ├── @ ForNode (location: (7,0)-(9,3))
│ ├── index: │ ├── index:
│ │ @ MultiTargetNode (location: (50...53)) │ │ @ MultiTargetNode (location: (7,4)-(7,7))
│ │ ├── targets: (length: 2) │ │ ├── targets: (length: 2)
│ │ │ ├── @ LocalVariableTargetNode (location: (50...51)) │ │ │ ├── @ LocalVariableTargetNode (location: (7,4)-(7,5))
│ │ │ │ ├── name: :i │ │ │ │ ├── name: :i
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableTargetNode (location: (52...53)) │ │ │ └── @ LocalVariableTargetNode (location: (7,6)-(7,7))
│ │ │ ├── name: :j │ │ │ ├── name: :j
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── lparen_loc: ∅ │ │ ├── lparen_loc: ∅
│ │ └── rparen_loc: ∅ │ │ └── rparen_loc: ∅
│ ├── collection: │ ├── collection:
│ │ @ RangeNode (location: (57...62)) │ │ @ RangeNode (location: (7,11)-(7,16))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (57...58)) │ │ │ @ IntegerNode (location: (7,11)-(7,12))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (60...62)) │ │ │ @ IntegerNode (location: (7,14)-(7,16))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (58...60) = ".." │ │ ├── operator_loc: (7,12)-(7,14) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (63...64)) │ │ @ StatementsNode (location: (8,0)-(8,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (63...64)) │ │ └── @ LocalVariableReadNode (location: (8,0)-(8,1))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── for_keyword_loc: (46...49) = "for" │ ├── for_keyword_loc: (7,0)-(7,3) = "for"
│ ├── in_keyword_loc: (54...56) = "in" │ ├── in_keyword_loc: (7,8)-(7,10) = "in"
│ ├── do_keyword_loc: ∅ │ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (65...68) = "end" │ └── end_keyword_loc: (9,0)-(9,3) = "end"
├── @ ForNode (location: (70...94)) ├── @ ForNode (location: (11,0)-(13,3))
│ ├── index: │ ├── index:
│ │ @ MultiTargetNode (location: (74...79)) │ │ @ MultiTargetNode (location: (11,4)-(11,9))
│ │ ├── targets: (length: 3) │ │ ├── targets: (length: 3)
│ │ │ ├── @ LocalVariableTargetNode (location: (74...75)) │ │ │ ├── @ LocalVariableTargetNode (location: (11,4)-(11,5))
│ │ │ │ ├── name: :i │ │ │ │ ├── name: :i
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableTargetNode (location: (76...77)) │ │ │ ├── @ LocalVariableTargetNode (location: (11,6)-(11,7))
│ │ │ │ ├── name: :j │ │ │ │ ├── name: :j
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableTargetNode (location: (78...79)) │ │ │ └── @ LocalVariableTargetNode (location: (11,8)-(11,9))
│ │ │ ├── name: :k │ │ │ ├── name: :k
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── lparen_loc: ∅ │ │ ├── lparen_loc: ∅
│ │ └── rparen_loc: ∅ │ │ └── rparen_loc: ∅
│ ├── collection: │ ├── collection:
│ │ @ RangeNode (location: (83...88)) │ │ @ RangeNode (location: (11,13)-(11,18))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (83...84)) │ │ │ @ IntegerNode (location: (11,13)-(11,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (86...88)) │ │ │ @ IntegerNode (location: (11,16)-(11,18))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (84...86) = ".." │ │ ├── operator_loc: (11,14)-(11,16) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (89...90)) │ │ @ StatementsNode (location: (12,0)-(12,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (89...90)) │ │ └── @ LocalVariableReadNode (location: (12,0)-(12,1))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── for_keyword_loc: (70...73) = "for" │ ├── for_keyword_loc: (11,0)-(11,3) = "for"
│ ├── in_keyword_loc: (80...82) = "in" │ ├── in_keyword_loc: (11,10)-(11,12) = "in"
│ ├── do_keyword_loc: ∅ │ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (91...94) = "end" │ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ ForNode (location: (96...119)) ├── @ ForNode (location: (15,0)-(17,3))
│ ├── index: │ ├── index:
│ │ @ LocalVariableTargetNode (location: (100...101)) │ │ @ LocalVariableTargetNode (location: (15,4)-(15,5))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── collection: │ ├── collection:
│ │ @ RangeNode (location: (105...110)) │ │ @ RangeNode (location: (15,9)-(15,14))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (105...106)) │ │ │ @ IntegerNode (location: (15,9)-(15,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (108...110)) │ │ │ @ IntegerNode (location: (15,12)-(15,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (106...108) = ".." │ │ ├── operator_loc: (15,10)-(15,12) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (114...115)) │ │ @ StatementsNode (location: (16,0)-(16,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (114...115)) │ │ └── @ LocalVariableReadNode (location: (16,0)-(16,1))
│ │ ├── name: :i │ │ ├── name: :i
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── for_keyword_loc: (96...99) = "for" │ ├── for_keyword_loc: (15,0)-(15,3) = "for"
│ ├── in_keyword_loc: (102...104) = "in" │ ├── in_keyword_loc: (15,6)-(15,8) = "in"
│ ├── do_keyword_loc: (111...113) = "do" │ ├── do_keyword_loc: (15,15)-(15,17) = "do"
│ └── end_keyword_loc: (116...119) = "end" │ └── end_keyword_loc: (17,0)-(17,3) = "end"
└── @ ForNode (location: (121...143)) └── @ ForNode (location: (19,0)-(19,22))
├── index: ├── index:
│ @ LocalVariableTargetNode (location: (125...126)) │ @ LocalVariableTargetNode (location: (19,4)-(19,5))
│ ├── name: :i │ ├── name: :i
│ └── depth: 0 │ └── depth: 0
├── collection: ├── collection:
│ @ RangeNode (location: (130...135)) │ @ RangeNode (location: (19,9)-(19,14))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (130...131)) │ │ @ IntegerNode (location: (19,9)-(19,10))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (133...135)) │ │ @ IntegerNode (location: (19,12)-(19,14))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── operator_loc: (131...133) = ".." │ ├── operator_loc: (19,10)-(19,12) = ".."
│ └── flags: ∅ │ └── flags: ∅
├── statements: ├── statements:
│ @ StatementsNode (location: (137...138)) │ @ StatementsNode (location: (19,16)-(19,17))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (137...138)) │ └── @ LocalVariableReadNode (location: (19,16)-(19,17))
│ ├── name: :i │ ├── name: :i
│ └── depth: 0 │ └── depth: 0
├── for_keyword_loc: (121...124) = "for" ├── for_keyword_loc: (19,0)-(19,3) = "for"
├── in_keyword_loc: (127...129) = "in" ├── in_keyword_loc: (19,6)-(19,8) = "in"
├── do_keyword_loc: ∅ ├── do_keyword_loc: ∅
└── end_keyword_loc: (140...143) = "end" └── end_keyword_loc: (19,19)-(19,22) = "end"

190
test/yarp/snapshots/global_variables.txt
View file

@ -1,164 +1,164 @@
@ ProgramNode (location: (0...349)) @ ProgramNode (location: (1,0)-(93,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...349)) @ StatementsNode (location: (1,0)-(93,4))
└── body: (length: 47) └── body: (length: 47)
├── @ GlobalVariableReadNode (location: (0...16)) ├── @ GlobalVariableReadNode (location: (1,0)-(1,16))
│ └── name: :$global_variable │ └── name: :$global_variable
├── @ GlobalVariableReadNode (location: (18...20)) ├── @ GlobalVariableReadNode (location: (3,0)-(3,2))
│ └── name: :$_ │ └── name: :$_
├── @ GlobalVariableReadNode (location: (22...25)) ├── @ GlobalVariableReadNode (location: (5,0)-(5,3))
│ └── name: :$-w │ └── name: :$-w
├── @ GlobalVariableReadNode (location: (27...37)) ├── @ GlobalVariableReadNode (location: (7,0)-(7,10))
│ └── name: :$LOAD_PATH │ └── name: :$LOAD_PATH
├── @ GlobalVariableReadNode (location: (39...45)) ├── @ GlobalVariableReadNode (location: (9,0)-(9,6))
│ └── name: :$stdin │ └── name: :$stdin
├── @ GlobalVariableReadNode (location: (47...54)) ├── @ GlobalVariableReadNode (location: (11,0)-(11,7))
│ └── name: :$stdout │ └── name: :$stdout
├── @ GlobalVariableReadNode (location: (56...63)) ├── @ GlobalVariableReadNode (location: (13,0)-(13,7))
│ └── name: :$stderr │ └── name: :$stderr
├── @ GlobalVariableReadNode (location: (65...67)) ├── @ GlobalVariableReadNode (location: (15,0)-(15,2))
│ └── name: :$! │ └── name: :$!
├── @ GlobalVariableReadNode (location: (69...71)) ├── @ GlobalVariableReadNode (location: (17,0)-(17,2))
│ └── name: :$? │ └── name: :$?
├── @ GlobalVariableReadNode (location: (73...75)) ├── @ GlobalVariableReadNode (location: (19,0)-(19,2))
│ └── name: :$~ │ └── name: :$~
├── @ BackReferenceReadNode (location: (77...79)) ├── @ BackReferenceReadNode (location: (21,0)-(21,2))
├── @ BackReferenceReadNode (location: (81...83)) ├── @ BackReferenceReadNode (location: (23,0)-(23,2))
├── @ BackReferenceReadNode (location: (85...87)) ├── @ BackReferenceReadNode (location: (25,0)-(25,2))
├── @ BackReferenceReadNode (location: (89...91)) ├── @ BackReferenceReadNode (location: (27,0)-(27,2))
├── @ GlobalVariableReadNode (location: (93...95)) ├── @ GlobalVariableReadNode (location: (29,0)-(29,2))
│ └── name: :$: │ └── name: :$:
├── @ GlobalVariableReadNode (location: (97...99)) ├── @ GlobalVariableReadNode (location: (31,0)-(31,2))
│ └── name: :$; │ └── name: :$;
├── @ GlobalVariableReadNode (location: (101...103)) ├── @ GlobalVariableReadNode (location: (33,0)-(33,2))
│ └── name: :$, │ └── name: :$,
├── @ GlobalVariableReadNode (location: (105...111)) ├── @ GlobalVariableReadNode (location: (35,0)-(35,6))
│ └── name: :$DEBUG │ └── name: :$DEBUG
├── @ GlobalVariableReadNode (location: (113...122)) ├── @ GlobalVariableReadNode (location: (37,0)-(37,9))
│ └── name: :$FILENAME │ └── name: :$FILENAME
├── @ GlobalVariableReadNode (location: (124...126)) ├── @ GlobalVariableReadNode (location: (39,0)-(39,2))
│ └── name: :$0 │ └── name: :$0
├── @ GlobalVariableReadNode (location: (128...131)) ├── @ GlobalVariableReadNode (location: (41,0)-(41,3))
│ └── name: :$-0 │ └── name: :$-0
├── @ GlobalVariableReadNode (location: (133...149)) ├── @ GlobalVariableReadNode (location: (43,0)-(43,16))
│ └── name: :$LOADED_FEATURES │ └── name: :$LOADED_FEATURES
├── @ GlobalVariableReadNode (location: (151...159)) ├── @ GlobalVariableReadNode (location: (45,0)-(45,8))
│ └── name: :$VERBOSE │ └── name: :$VERBOSE
├── @ GlobalVariableReadNode (location: (161...164)) ├── @ GlobalVariableReadNode (location: (47,0)-(47,3))
│ └── name: :$-K │ └── name: :$-K
├── @ SymbolNode (location: (166...183)) ├── @ SymbolNode (location: (49,0)-(49,17))
│ ├── opening_loc: (166...167) = ":" │ ├── opening_loc: (49,0)-(49,1) = ":"
│ ├── value_loc: (167...183) = "$global_variable" │ ├── value_loc: (49,1)-(49,17) = "$global_variable"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$global_variable" │ └── unescaped: "$global_variable"
├── @ SymbolNode (location: (185...188)) ├── @ SymbolNode (location: (51,0)-(51,3))
│ ├── opening_loc: (185...186) = ":" │ ├── opening_loc: (51,0)-(51,1) = ":"
│ ├── value_loc: (186...188) = "$_" │ ├── value_loc: (51,1)-(51,3) = "$_"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$_" │ └── unescaped: "$_"
├── @ SymbolNode (location: (190...194)) ├── @ SymbolNode (location: (53,0)-(53,4))
│ ├── opening_loc: (190...191) = ":" │ ├── opening_loc: (53,0)-(53,1) = ":"
│ ├── value_loc: (191...194) = "$-w" │ ├── value_loc: (53,1)-(53,4) = "$-w"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$-w" │ └── unescaped: "$-w"
├── @ SymbolNode (location: (196...207)) ├── @ SymbolNode (location: (55,0)-(55,11))
│ ├── opening_loc: (196...197) = ":" │ ├── opening_loc: (55,0)-(55,1) = ":"
│ ├── value_loc: (197...207) = "$LOAD_PATH" │ ├── value_loc: (55,1)-(55,11) = "$LOAD_PATH"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$LOAD_PATH" │ └── unescaped: "$LOAD_PATH"
├── @ SymbolNode (location: (209...216)) ├── @ SymbolNode (location: (57,0)-(57,7))
│ ├── opening_loc: (209...210) = ":" │ ├── opening_loc: (57,0)-(57,1) = ":"
│ ├── value_loc: (210...216) = "$stdin" │ ├── value_loc: (57,1)-(57,7) = "$stdin"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$stdin" │ └── unescaped: "$stdin"
├── @ SymbolNode (location: (218...226)) ├── @ SymbolNode (location: (59,0)-(59,8))
│ ├── opening_loc: (218...219) = ":" │ ├── opening_loc: (59,0)-(59,1) = ":"
│ ├── value_loc: (219...226) = "$stdout" │ ├── value_loc: (59,1)-(59,8) = "$stdout"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$stdout" │ └── unescaped: "$stdout"
├── @ SymbolNode (location: (228...236)) ├── @ SymbolNode (location: (61,0)-(61,8))
│ ├── opening_loc: (228...229) = ":" │ ├── opening_loc: (61,0)-(61,1) = ":"
│ ├── value_loc: (229...236) = "$stderr" │ ├── value_loc: (61,1)-(61,8) = "$stderr"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$stderr" │ └── unescaped: "$stderr"
├── @ SymbolNode (location: (238...241)) ├── @ SymbolNode (location: (63,0)-(63,3))
│ ├── opening_loc: (238...239) = ":" │ ├── opening_loc: (63,0)-(63,1) = ":"
│ ├── value_loc: (239...241) = "$!" │ ├── value_loc: (63,1)-(63,3) = "$!"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$!" │ └── unescaped: "$!"
├── @ SymbolNode (location: (243...246)) ├── @ SymbolNode (location: (65,0)-(65,3))
│ ├── opening_loc: (243...244) = ":" │ ├── opening_loc: (65,0)-(65,1) = ":"
│ ├── value_loc: (244...246) = "$?" │ ├── value_loc: (65,1)-(65,3) = "$?"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$?" │ └── unescaped: "$?"
├── @ SymbolNode (location: (248...251)) ├── @ SymbolNode (location: (67,0)-(67,3))
│ ├── opening_loc: (248...249) = ":" │ ├── opening_loc: (67,0)-(67,1) = ":"
│ ├── value_loc: (249...251) = "$~" │ ├── value_loc: (67,1)-(67,3) = "$~"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$~" │ └── unescaped: "$~"
├── @ SymbolNode (location: (253...256)) ├── @ SymbolNode (location: (69,0)-(69,3))
│ ├── opening_loc: (253...254) = ":" │ ├── opening_loc: (69,0)-(69,1) = ":"
│ ├── value_loc: (254...256) = "$&" │ ├── value_loc: (69,1)-(69,3) = "$&"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$&" │ └── unescaped: "$&"
├── @ SymbolNode (location: (258...261)) ├── @ SymbolNode (location: (71,0)-(71,3))
│ ├── opening_loc: (258...259) = ":" │ ├── opening_loc: (71,0)-(71,1) = ":"
│ ├── value_loc: (259...261) = "$`" │ ├── value_loc: (71,1)-(71,3) = "$`"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$`" │ └── unescaped: "$`"
├── @ SymbolNode (location: (263...266)) ├── @ SymbolNode (location: (73,0)-(73,3))
│ ├── opening_loc: (263...264) = ":" │ ├── opening_loc: (73,0)-(73,1) = ":"
│ ├── value_loc: (264...266) = "$'" │ ├── value_loc: (73,1)-(73,3) = "$'"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$'" │ └── unescaped: "$'"
├── @ SymbolNode (location: (268...271)) ├── @ SymbolNode (location: (75,0)-(75,3))
│ ├── opening_loc: (268...269) = ":" │ ├── opening_loc: (75,0)-(75,1) = ":"
│ ├── value_loc: (269...271) = "$+" │ ├── value_loc: (75,1)-(75,3) = "$+"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$+" │ └── unescaped: "$+"
├── @ SymbolNode (location: (273...276)) ├── @ SymbolNode (location: (77,0)-(77,3))
│ ├── opening_loc: (273...274) = ":" │ ├── opening_loc: (77,0)-(77,1) = ":"
│ ├── value_loc: (274...276) = "$:" │ ├── value_loc: (77,1)-(77,3) = "$:"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$:" │ └── unescaped: "$:"
├── @ SymbolNode (location: (278...281)) ├── @ SymbolNode (location: (79,0)-(79,3))
│ ├── opening_loc: (278...279) = ":" │ ├── opening_loc: (79,0)-(79,1) = ":"
│ ├── value_loc: (279...281) = "$;" │ ├── value_loc: (79,1)-(79,3) = "$;"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$;" │ └── unescaped: "$;"
├── @ SymbolNode (location: (283...290)) ├── @ SymbolNode (location: (81,0)-(81,7))
│ ├── opening_loc: (283...284) = ":" │ ├── opening_loc: (81,0)-(81,1) = ":"
│ ├── value_loc: (284...290) = "$DEBUG" │ ├── value_loc: (81,1)-(81,7) = "$DEBUG"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$DEBUG" │ └── unescaped: "$DEBUG"
├── @ SymbolNode (location: (292...302)) ├── @ SymbolNode (location: (83,0)-(83,10))
│ ├── opening_loc: (292...293) = ":" │ ├── opening_loc: (83,0)-(83,1) = ":"
│ ├── value_loc: (293...302) = "$FILENAME" │ ├── value_loc: (83,1)-(83,10) = "$FILENAME"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$FILENAME" │ └── unescaped: "$FILENAME"
├── @ SymbolNode (location: (304...307)) ├── @ SymbolNode (location: (85,0)-(85,3))
│ ├── opening_loc: (304...305) = ":" │ ├── opening_loc: (85,0)-(85,1) = ":"
│ ├── value_loc: (305...307) = "$0" │ ├── value_loc: (85,1)-(85,3) = "$0"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$0" │ └── unescaped: "$0"
├── @ SymbolNode (location: (309...313)) ├── @ SymbolNode (location: (87,0)-(87,4))
│ ├── opening_loc: (309...310) = ":" │ ├── opening_loc: (87,0)-(87,1) = ":"
│ ├── value_loc: (310...313) = "$-0" │ ├── value_loc: (87,1)-(87,4) = "$-0"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$-0" │ └── unescaped: "$-0"
├── @ SymbolNode (location: (315...332)) ├── @ SymbolNode (location: (89,0)-(89,17))
│ ├── opening_loc: (315...316) = ":" │ ├── opening_loc: (89,0)-(89,1) = ":"
│ ├── value_loc: (316...332) = "$LOADED_FEATURES" │ ├── value_loc: (89,1)-(89,17) = "$LOADED_FEATURES"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$LOADED_FEATURES" │ └── unescaped: "$LOADED_FEATURES"
├── @ SymbolNode (location: (334...343)) ├── @ SymbolNode (location: (91,0)-(91,9))
│ ├── opening_loc: (334...335) = ":" │ ├── opening_loc: (91,0)-(91,1) = ":"
│ ├── value_loc: (335...343) = "$VERBOSE" │ ├── value_loc: (91,1)-(91,9) = "$VERBOSE"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "$VERBOSE" │ └── unescaped: "$VERBOSE"
└── @ SymbolNode (location: (345...349)) └── @ SymbolNode (location: (93,0)-(93,4))
├── opening_loc: (345...346) = ":" ├── opening_loc: (93,0)-(93,1) = ":"
├── value_loc: (346...349) = "$-K" ├── value_loc: (93,1)-(93,4) = "$-K"
├── closing_loc: ∅ ├── closing_loc: ∅
└── unescaped: "$-K" └── unescaped: "$-K"

260
test/yarp/snapshots/hashes.txt
View file

@ -1,25 +1,25 @@
@ ProgramNode (location: (0...167)) @ ProgramNode (location: (1,0)-(26,3))
├── locals: [:a] ├── locals: [:a]
└── statements: └── statements:
@ StatementsNode (location: (0...167)) @ StatementsNode (location: (1,0)-(26,3))
└── body: (length: 9) └── body: (length: 9)
├── @ HashNode (location: (0...2)) ├── @ HashNode (location: (1,0)-(1,2))
│ ├── opening_loc: (0...1) = "{" │ ├── opening_loc: (1,0)-(1,1) = "{"
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ └── closing_loc: (1...2) = "}" │ └── closing_loc: (1,1)-(1,2) = "}"
├── @ HashNode (location: (4...7)) ├── @ HashNode (location: (3,0)-(4,1))
│ ├── opening_loc: (4...5) = "{" │ ├── opening_loc: (3,0)-(3,1) = "{"
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ └── closing_loc: (6...7) = "}" │ └── closing_loc: (4,0)-(4,1) = "}"
├── @ HashNode (location: (9...27)) ├── @ HashNode (location: (6,0)-(6,18))
│ ├── opening_loc: (9...10) = "{" │ ├── opening_loc: (6,0)-(6,1) = "{"
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (11...17)) │ │ ├── @ AssocNode (location: (6,2)-(6,8))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ CallNode (location: (11...12)) │ │ │ │ @ CallNode (location: (6,2)-(6,3))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (11...12) = "a" │ │ │ │ ├── message_loc: (6,2)-(6,3) = "a"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -27,23 +27,23 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "a" │ │ │ │ └── name: "a"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (16...17)) │ │ │ │ @ CallNode (location: (6,7)-(6,8))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (16...17) = "b" │ │ │ │ ├── message_loc: (6,7)-(6,8) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── operator_loc: (13...15) = "=>" │ │ │ └── operator_loc: (6,4)-(6,6) = "=>"
│ │ └── @ AssocNode (location: (19...25)) │ │ └── @ AssocNode (location: (6,10)-(6,16))
│ │ ├── key: │ │ ├── key:
│ │ │ @ CallNode (location: (19...20)) │ │ │ @ CallNode (location: (6,10)-(6,11))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (19...20) = "c" │ │ │ ├── message_loc: (6,10)-(6,11) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -51,27 +51,27 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "c" │ │ │ └── name: "c"
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (24...25)) │ │ │ @ CallNode (location: (6,15)-(6,16))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (24...25) = "d" │ │ │ ├── message_loc: (6,15)-(6,16) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ └── operator_loc: (21...23) = "=>" │ │ └── operator_loc: (6,12)-(6,14) = "=>"
│ └── closing_loc: (26...27) = "}" │ └── closing_loc: (6,17)-(6,18) = "}"
├── @ HashNode (location: (29...44)) ├── @ HashNode (location: (8,0)-(8,15))
│ ├── opening_loc: (29...30) = "{" │ ├── opening_loc: (8,0)-(8,1) = "{"
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (31...37)) │ │ ├── @ AssocNode (location: (8,2)-(8,8))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ CallNode (location: (31...32)) │ │ │ │ @ CallNode (location: (8,2)-(8,3))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (31...32) = "a" │ │ │ │ ├── message_loc: (8,2)-(8,3) = "a"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -79,46 +79,46 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "a" │ │ │ │ └── name: "a"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (36...37)) │ │ │ │ @ CallNode (location: (8,7)-(8,8))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (36...37) = "b" │ │ │ │ ├── message_loc: (8,7)-(8,8) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── operator_loc: (33...35) = "=>" │ │ │ └── operator_loc: (8,4)-(8,6) = "=>"
│ │ └── @ AssocSplatNode (location: (39...42)) │ │ └── @ AssocSplatNode (location: (8,10)-(8,13))
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (41...42)) │ │ │ @ CallNode (location: (8,12)-(8,13))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (41...42) = "c" │ │ │ ├── message_loc: (8,12)-(8,13) = "c"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "c" │ │ │ └── name: "c"
│ │ └── operator_loc: (39...41) = "**" │ │ └── operator_loc: (8,10)-(8,12) = "**"
│ └── closing_loc: (43...44) = "}" │ └── closing_loc: (8,14)-(8,15) = "}"
├── @ HashNode (location: (46...79)) ├── @ HashNode (location: (10,0)-(16,5))
│ ├── opening_loc: (46...47) = "{" │ ├── opening_loc: (10,0)-(10,1) = "{"
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (54...58)) │ │ ├── @ AssocNode (location: (11,6)-(11,10))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (54...56)) │ │ │ │ @ SymbolNode (location: (11,6)-(11,8))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (54...55) = "a" │ │ │ │ ├── value_loc: (11,6)-(11,7) = "a"
│ │ │ │ ├── closing_loc: (55...56) = ":" │ │ │ │ ├── closing_loc: (11,7)-(11,8) = ":"
│ │ │ │ └── unescaped: "a" │ │ │ │ └── unescaped: "a"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (57...58)) │ │ │ │ @ CallNode (location: (11,9)-(11,10))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (57...58) = "b" │ │ │ │ ├── message_loc: (11,9)-(11,10) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -126,18 +126,18 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── operator_loc: ∅ │ │ │ └── operator_loc: ∅
│ │ └── @ AssocNode (location: (66...70)) │ │ └── @ AssocNode (location: (12,6)-(12,10))
│ │ ├── key: │ │ ├── key:
│ │ │ @ SymbolNode (location: (66...68)) │ │ │ @ SymbolNode (location: (12,6)-(12,8))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (66...67) = "c" │ │ │ ├── value_loc: (12,6)-(12,7) = "c"
│ │ │ ├── closing_loc: (67...68) = ":" │ │ │ ├── closing_loc: (12,7)-(12,8) = ":"
│ │ │ └── unescaped: "c" │ │ │ └── unescaped: "c"
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (69...70)) │ │ │ @ CallNode (location: (12,9)-(12,10))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (69...70) = "d" │ │ │ ├── message_loc: (12,9)-(12,10) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -145,22 +145,22 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ └── operator_loc: ∅ │ │ └── operator_loc: ∅
│ └── closing_loc: (78...79) = "}" │ └── closing_loc: (16,4)-(16,5) = "}"
├── @ HashNode (location: (81...106)) ├── @ HashNode (location: (18,0)-(18,25))
│ ├── opening_loc: (81...82) = "{" │ ├── opening_loc: (18,0)-(18,1) = "{"
│ ├── elements: (length: 4) │ ├── elements: (length: 4)
│ │ ├── @ AssocNode (location: (83...87)) │ │ ├── @ AssocNode (location: (18,2)-(18,6))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (83...85)) │ │ │ │ @ SymbolNode (location: (18,2)-(18,4))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (83...84) = "a" │ │ │ │ ├── value_loc: (18,2)-(18,3) = "a"
│ │ │ │ ├── closing_loc: (84...85) = ":" │ │ │ │ ├── closing_loc: (18,3)-(18,4) = ":"
│ │ │ │ └── unescaped: "a" │ │ │ │ └── unescaped: "a"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (86...87)) │ │ │ │ @ CallNode (location: (18,5)-(18,6))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (86...87) = "b" │ │ │ │ ├── message_loc: (18,5)-(18,6) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -168,18 +168,18 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b" │ │ │ │ └── name: "b"
│ │ │ └── operator_loc: ∅ │ │ │ └── operator_loc: ∅
│ │ ├── @ AssocNode (location: (89...93)) │ │ ├── @ AssocNode (location: (18,8)-(18,12))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (89...91)) │ │ │ │ @ SymbolNode (location: (18,8)-(18,10))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (89...90) = "c" │ │ │ │ ├── value_loc: (18,8)-(18,9) = "c"
│ │ │ │ ├── closing_loc: (90...91) = ":" │ │ │ │ ├── closing_loc: (18,9)-(18,10) = ":"
│ │ │ │ └── unescaped: "c" │ │ │ │ └── unescaped: "c"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (92...93)) │ │ │ │ @ CallNode (location: (18,11)-(18,12))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (92...93) = "d" │ │ │ │ ├── message_loc: (18,11)-(18,12) = "d"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -187,31 +187,31 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "d" │ │ │ │ └── name: "d"
│ │ │ └── operator_loc: ∅ │ │ │ └── operator_loc: ∅
│ │ ├── @ AssocSplatNode (location: (95...98)) │ │ ├── @ AssocSplatNode (location: (18,14)-(18,17))
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (97...98)) │ │ │ │ @ CallNode (location: (18,16)-(18,17))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (97...98) = "e" │ │ │ │ ├── message_loc: (18,16)-(18,17) = "e"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "e" │ │ │ │ └── name: "e"
│ │ │ └── operator_loc: (95...97) = "**" │ │ │ └── operator_loc: (18,14)-(18,16) = "**"
│ │ └── @ AssocNode (location: (100...104)) │ │ └── @ AssocNode (location: (18,19)-(18,23))
│ │ ├── key: │ │ ├── key:
│ │ │ @ SymbolNode (location: (100...102)) │ │ │ @ SymbolNode (location: (18,19)-(18,21))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (100...101) = "f" │ │ │ ├── value_loc: (18,19)-(18,20) = "f"
│ │ │ ├── closing_loc: (101...102) = ":" │ │ │ ├── closing_loc: (18,20)-(18,21) = ":"
│ │ │ └── unescaped: "f" │ │ │ └── unescaped: "f"
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (103...104)) │ │ │ @ CallNode (location: (18,22)-(18,23))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (103...104) = "g" │ │ │ ├── message_loc: (18,22)-(18,23) = "g"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -219,24 +219,24 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "g" │ │ │ └── name: "g"
│ │ └── operator_loc: ∅ │ │ └── operator_loc: ∅
│ └── closing_loc: (105...106) = "}" │ └── closing_loc: (18,24)-(18,25) = "}"
├── @ HashNode (location: (108...120)) ├── @ HashNode (location: (20,0)-(20,12))
│ ├── opening_loc: (108...109) = "{" │ ├── opening_loc: (20,0)-(20,1) = "{"
│ ├── elements: (length: 1) │ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (110...118)) │ │ └── @ AssocNode (location: (20,2)-(20,10))
│ │ ├── key: │ │ ├── key:
│ │ │ @ SymbolNode (location: (110...114)) │ │ │ @ SymbolNode (location: (20,2)-(20,6))
│ │ │ ├── opening_loc: (110...111) = "\"" │ │ │ ├── opening_loc: (20,2)-(20,3) = "\""
│ │ │ ├── value_loc: (111...112) = "a" │ │ │ ├── value_loc: (20,3)-(20,4) = "a"
│ │ │ ├── closing_loc: (112...114) = "\":" │ │ │ ├── closing_loc: (20,4)-(20,6) = "\":"
│ │ │ └── unescaped: "a" │ │ │ └── unescaped: "a"
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (115...118)) │ │ │ @ CallNode (location: (20,7)-(20,10))
│ │ │ ├── receiver: │ │ │ ├── receiver:
│ │ │ │ @ CallNode (location: (116...118)) │ │ │ │ @ CallNode (location: (20,8)-(20,10))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (116...118) = "b?" │ │ │ │ ├── message_loc: (20,8)-(20,10) = "b?"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -244,7 +244,7 @@
│ │ │ │ ├── flags: ∅ │ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "b?" │ │ │ │ └── name: "b?"
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (115...116) = "!" │ │ │ ├── message_loc: (20,7)-(20,8) = "!"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -252,82 +252,82 @@
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "!" │ │ │ └── name: "!"
│ │ └── operator_loc: ∅ │ │ └── operator_loc: ∅
│ └── closing_loc: (119...120) = "}" │ └── closing_loc: (20,11)-(20,12) = "}"
├── @ LocalVariableWriteNode (location: (122...127)) ├── @ LocalVariableWriteNode (location: (22,0)-(22,5))
│ ├── name: :a │ ├── name: :a
│ ├── depth: 0 │ ├── depth: 0
│ ├── name_loc: (122...123) = "a" │ ├── name_loc: (22,0)-(22,1) = "a"
│ ├── value: │ ├── value:
│ │ @ IntegerNode (location: (126...127)) │ │ @ IntegerNode (location: (22,4)-(22,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (124...125) = "=" │ └── operator_loc: (22,2)-(22,3) = "="
└── @ CallNode (location: (128...167)) └── @ CallNode (location: (23,0)-(26,3))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (128...131) = "tap" ├── message_loc: (23,0)-(23,3) = "tap"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (132...167)) │ @ BlockNode (location: (23,4)-(26,3))
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (137...163)) │ │ @ StatementsNode (location: (24,2)-(25,20))
│ │ └── body: (length: 2) │ │ └── body: (length: 2)
│ │ ├── @ LocalVariableWriteNode (location: (137...142)) │ │ ├── @ LocalVariableWriteNode (location: (24,2)-(24,7))
│ │ │ ├── name: :b │ │ │ ├── name: :b
│ │ │ ├── depth: 0 │ │ │ ├── depth: 0
│ │ │ ├── name_loc: (137...138) = "b" │ │ │ ├── name_loc: (24,2)-(24,3) = "b"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (141...142)) │ │ │ │ @ IntegerNode (location: (24,6)-(24,7))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (139...140) = "=" │ │ │ └── operator_loc: (24,4)-(24,5) = "="
│ │ └── @ HashNode (location: (145...163)) │ │ └── @ HashNode (location: (25,2)-(25,20))
│ │ ├── opening_loc: (145...146) = "{" │ │ ├── opening_loc: (25,2)-(25,3) = "{"
│ │ ├── elements: (length: 4) │ │ ├── elements: (length: 4)
│ │ │ ├── @ AssocNode (location: (147...149)) │ │ │ ├── @ AssocNode (location: (25,4)-(25,6))
│ │ │ │ ├── key: │ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (147...149)) │ │ │ │ │ @ SymbolNode (location: (25,4)-(25,6))
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (147...148) = "a" │ │ │ │ │ ├── value_loc: (25,4)-(25,5) = "a"
│ │ │ │ │ ├── closing_loc: (148...149) = ":" │ │ │ │ │ ├── closing_loc: (25,5)-(25,6) = ":"
│ │ │ │ │ └── unescaped: "a" │ │ │ │ │ └── unescaped: "a"
│ │ │ │ ├── value: │ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (147...149)) │ │ │ │ │ @ ImplicitNode (location: (25,4)-(25,6))
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ LocalVariableReadNode (location: (147...149)) │ │ │ │ │ @ LocalVariableReadNode (location: (25,4)-(25,6))
│ │ │ │ │ ├── name: :a │ │ │ │ │ ├── name: :a
│ │ │ │ │ └── depth: 1 │ │ │ │ │ └── depth: 1
│ │ │ │ └── operator_loc: ∅ │ │ │ │ └── operator_loc: ∅
│ │ │ ├── @ AssocNode (location: (151...153)) │ │ │ ├── @ AssocNode (location: (25,8)-(25,10))
│ │ │ │ ├── key: │ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (151...153)) │ │ │ │ │ @ SymbolNode (location: (25,8)-(25,10))
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (151...152) = "b" │ │ │ │ │ ├── value_loc: (25,8)-(25,9) = "b"
│ │ │ │ │ ├── closing_loc: (152...153) = ":" │ │ │ │ │ ├── closing_loc: (25,9)-(25,10) = ":"
│ │ │ │ │ └── unescaped: "b" │ │ │ │ │ └── unescaped: "b"
│ │ │ │ ├── value: │ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (151...153)) │ │ │ │ │ @ ImplicitNode (location: (25,8)-(25,10))
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ LocalVariableReadNode (location: (151...153)) │ │ │ │ │ @ LocalVariableReadNode (location: (25,8)-(25,10))
│ │ │ │ │ ├── name: :b │ │ │ │ │ ├── name: :b
│ │ │ │ │ └── depth: 0 │ │ │ │ │ └── depth: 0
│ │ │ │ └── operator_loc: ∅ │ │ │ │ └── operator_loc: ∅
│ │ │ ├── @ AssocNode (location: (155...157)) │ │ │ ├── @ AssocNode (location: (25,12)-(25,14))
│ │ │ │ ├── key: │ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (155...157)) │ │ │ │ │ @ SymbolNode (location: (25,12)-(25,14))
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (155...156) = "c" │ │ │ │ │ ├── value_loc: (25,12)-(25,13) = "c"
│ │ │ │ │ ├── closing_loc: (156...157) = ":" │ │ │ │ │ ├── closing_loc: (25,13)-(25,14) = ":"
│ │ │ │ │ └── unescaped: "c" │ │ │ │ │ └── unescaped: "c"
│ │ │ │ ├── value: │ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (155...157)) │ │ │ │ │ @ ImplicitNode (location: (25,12)-(25,14))
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ CallNode (location: (155...157)) │ │ │ │ │ @ CallNode (location: (25,12)-(25,14))
│ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (155...156) = "c" │ │ │ │ │ ├── message_loc: (25,12)-(25,13) = "c"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
@ -335,21 +335,21 @@
│ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "c" │ │ │ │ │ └── name: "c"
│ │ │ │ └── operator_loc: ∅ │ │ │ │ └── operator_loc: ∅
│ │ │ └── @ AssocNode (location: (159...161)) │ │ │ └── @ AssocNode (location: (25,16)-(25,18))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (159...161)) │ │ │ │ @ SymbolNode (location: (25,16)-(25,18))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (159...160) = "D" │ │ │ │ ├── value_loc: (25,16)-(25,17) = "D"
│ │ │ │ ├── closing_loc: (160...161) = ":" │ │ │ │ ├── closing_loc: (25,17)-(25,18) = ":"
│ │ │ │ └── unescaped: "D" │ │ │ │ └── unescaped: "D"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (159...161)) │ │ │ │ @ ImplicitNode (location: (25,16)-(25,18))
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ ConstantReadNode (location: (159...161)) │ │ │ │ @ ConstantReadNode (location: (25,16)-(25,18))
│ │ │ │ └── name: :D │ │ │ │ └── name: :D
│ │ │ └── operator_loc: ∅ │ │ │ └── operator_loc: ∅
│ │ └── closing_loc: (162...163) = "}" │ │ └── closing_loc: (25,19)-(25,20) = "}"
│ ├── opening_loc: (132...134) = "do" │ ├── opening_loc: (23,4)-(23,6) = "do"
│ └── closing_loc: (164...167) = "end" │ └── closing_loc: (26,0)-(26,3) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "tap" └── name: "tap"

68
test/yarp/snapshots/heredoc_with_escaped_newline_at_start.txt
View file

@ -1,63 +1,63 @@
@ ProgramNode (location: (0...62)) @ ProgramNode (location: (1,0)-(5,25))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...62)) @ StatementsNode (location: (1,0)-(5,25))
└── body: (length: 2) └── body: (length: 2)
├── @ CallNode (location: (0...25)) ├── @ CallNode (location: (1,0)-(1,25))
│ ├── receiver: │ ├── receiver:
│ │ @ StringNode (location: (0...9)) │ │ @ StringNode (location: (1,0)-(1,9))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (0...9) = "<<-TARGET" │ │ ├── opening_loc: (1,0)-(1,9) = "<<-TARGET"
│ │ ├── content_loc: (27...27) = "" │ │ ├── content_loc: (2,0)-(1,0) = ""
│ │ ├── closing_loc: (27...34) = "TARGET\n" │ │ ├── closing_loc: (2,0)-(2,0) = "TARGET\n"
│ │ └── unescaped: "" │ │ └── unescaped: ""
│ ├── call_operator_loc: (9...10) = "." │ ├── call_operator_loc: (1,9)-(1,10) = "."
│ ├── message_loc: (10...14) = "gsub" │ ├── message_loc: (1,10)-(1,14) = "gsub"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (15...25)) │ │ @ ArgumentsNode (location: (1,15)-(1,25))
│ │ └── arguments: (length: 2) │ │ └── arguments: (length: 2)
│ │ ├── @ RegularExpressionNode (location: (15...21)) │ │ ├── @ RegularExpressionNode (location: (1,15)-(1,21))
│ │ │ ├── opening_loc: (15...16) = "/" │ │ │ ├── opening_loc: (1,15)-(1,16) = "/"
│ │ │ ├── content_loc: (16...20) = "^\\s{" │ │ │ ├── content_loc: (1,16)-(1,20) = "^\\s{"
│ │ │ ├── closing_loc: (20...21) = "/" │ │ │ ├── closing_loc: (1,20)-(1,21) = "/"
│ │ │ ├── unescaped: "^ {" │ │ │ ├── unescaped: "^ {"
│ │ │ └── flags: ∅ │ │ │ └── flags: ∅
│ │ └── @ StringNode (location: (23...25)) │ │ └── @ StringNode (location: (1,23)-(1,25))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (23...24) = "'" │ │ ├── opening_loc: (1,23)-(1,24) = "'"
│ │ ├── content_loc: (24...24) = "" │ │ ├── content_loc: (1,24)-(1,24) = ""
│ │ ├── closing_loc: (24...25) = "'" │ │ ├── closing_loc: (1,24)-(1,25) = "'"
│ │ └── unescaped: "" │ │ └── unescaped: ""
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "gsub" │ └── name: "gsub"
└── @ CallNode (location: (37...62)) └── @ CallNode (location: (5,0)-(5,25))
├── receiver: ├── receiver:
│ @ StringNode (location: (37...46)) │ @ StringNode (location: (5,0)-(5,9))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (37...46) = "<<-TARGET" │ ├── opening_loc: (5,0)-(5,9) = "<<-TARGET"
│ ├── content_loc: (65...65) = "" │ ├── content_loc: (6,0)-(5,0) = ""
│ ├── closing_loc: (65...73) = "TARGET\r\n" │ ├── closing_loc: (6,0)-(6,0) = "TARGET\r\n"
│ └── unescaped: "" │ └── unescaped: ""
├── call_operator_loc: (46...47) = "." ├── call_operator_loc: (5,9)-(5,10) = "."
├── message_loc: (47...51) = "gsub" ├── message_loc: (5,10)-(5,14) = "gsub"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (52...62)) │ @ ArgumentsNode (location: (5,15)-(5,25))
│ └── arguments: (length: 2) │ └── arguments: (length: 2)
│ ├── @ RegularExpressionNode (location: (52...58)) │ ├── @ RegularExpressionNode (location: (5,15)-(5,21))
│ │ ├── opening_loc: (52...53) = "/" │ │ ├── opening_loc: (5,15)-(5,16) = "/"
│ │ ├── content_loc: (53...57) = "^\\s{" │ │ ├── content_loc: (5,16)-(5,20) = "^\\s{"
│ │ ├── closing_loc: (57...58) = "/" │ │ ├── closing_loc: (5,20)-(5,21) = "/"
│ │ ├── unescaped: "^ {" │ │ ├── unescaped: "^ {"
│ │ └── flags: ∅ │ │ └── flags: ∅
│ └── @ StringNode (location: (60...62)) │ └── @ StringNode (location: (5,23)-(5,25))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (60...61) = "'" │ ├── opening_loc: (5,23)-(5,24) = "'"
│ ├── content_loc: (61...61) = "" │ ├── content_loc: (5,24)-(5,24) = ""
│ ├── closing_loc: (61...62) = "'" │ ├── closing_loc: (5,24)-(5,25) = "'"
│ └── unescaped: "" │ └── unescaped: ""
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅

12
test/yarp/snapshots/heredoc_with_trailing_newline.txt
View file

@ -1,11 +1,11 @@
@ ProgramNode (location: (0...6)) @ ProgramNode (location: (1,0)-(1,6))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...6)) @ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1) └── body: (length: 1)
└── @ StringNode (location: (0...6)) └── @ StringNode (location: (1,0)-(1,6))
├── flags: ∅ ├── flags: ∅
├── opening_loc: (0...6) = "<<-END" ├── opening_loc: (1,0)-(1,6) = "<<-END"
├── content_loc: (7...7) = "" ├── content_loc: (2,0)-(1,0) = ""
├── closing_loc: (7...10) = "END" ├── closing_loc: (2,0)-(2,3) = "END"
└── unescaped: "" └── unescaped: ""

34
test/yarp/snapshots/heredocs_nested.txt
View file

@ -1,33 +1,33 @@
@ ProgramNode (location: (0...7)) @ ProgramNode (location: (1,0)-(1,7))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...7)) @ StatementsNode (location: (1,0)-(1,7))
└── body: (length: 1) └── body: (length: 1)
└── @ InterpolatedStringNode (location: (0...7)) └── @ InterpolatedStringNode (location: (1,0)-(1,7))
├── opening_loc: (0...7) = "<<~RUBY" ├── opening_loc: (1,0)-(1,7) = "<<~RUBY"
├── parts: (length: 3) ├── parts: (length: 3)
│ ├── @ StringNode (location: (8...12)) │ ├── @ StringNode (location: (2,0)-(2,0))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (8...12) = "pre\n" │ │ ├── content_loc: (2,0)-(2,0) = "pre\n"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "pre\n" │ │ └── unescaped: "pre\n"
│ ├── @ EmbeddedStatementsNode (location: (12...36)) │ ├── @ EmbeddedStatementsNode (location: (3,0)-(7,1))
│ │ ├── opening_loc: (12...14) = "\#{" │ │ ├── opening_loc: (3,0)-(3,2) = "\#{"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (15...21)) │ │ │ @ StatementsNode (location: (4,0)-(4,6))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ StringNode (location: (15...21)) │ │ │ └── @ StringNode (location: (4,0)-(4,6))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (15...21) = "<<RUBY" │ │ │ ├── opening_loc: (4,0)-(4,6) = "<<RUBY"
│ │ │ ├── content_loc: (22...30) = " hello\n" │ │ │ ├── content_loc: (5,0)-(5,0) = " hello\n"
│ │ │ ├── closing_loc: (30...35) = "RUBY\n" │ │ │ ├── closing_loc: (6,0)-(6,0) = "RUBY\n"
│ │ │ └── unescaped: " hello\n" │ │ │ └── unescaped: " hello\n"
│ │ └── closing_loc: (35...36) = "}" │ │ └── closing_loc: (7,0)-(7,1) = "}"
│ └── @ StringNode (location: (36...42)) │ └── @ StringNode (location: (7,1)-(8,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── content_loc: (36...42) = "\npost\n" │ ├── content_loc: (7,1)-(8,0) = "\npost\n"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "\npost\n" │ └── unescaped: "\npost\n"
└── closing_loc: (42...47) = "RUBY\n" └── closing_loc: (9,0)-(9,0) = "RUBY\n"

20
test/yarp/snapshots/heredocs_with_ignored_newlines.txt
View file

@ -1,17 +1,17 @@
@ ProgramNode (location: (0...23)) @ ProgramNode (location: (1,0)-(4,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...23)) @ StatementsNode (location: (1,0)-(4,8))
└── body: (length: 2) └── body: (length: 2)
├── @ StringNode (location: (0...7)) ├── @ StringNode (location: (1,0)-(1,7))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (0...7) = "<<-HERE" │ ├── opening_loc: (1,0)-(1,7) = "<<-HERE"
│ ├── content_loc: (9...9) = "" │ ├── content_loc: (2,0)-(1,0) = ""
│ ├── closing_loc: (9...14) = "HERE\n" │ ├── closing_loc: (2,0)-(2,0) = "HERE\n"
│ └── unescaped: "" │ └── unescaped: ""
└── @ StringNode (location: (15...23)) └── @ StringNode (location: (4,0)-(4,8))
├── flags: ∅ ├── flags: ∅
├── opening_loc: (15...23) = "<<~THERE" ├── opening_loc: (4,0)-(4,8) = "<<~THERE"
├── content_loc: (25...100) = " way over\n <<HERE\n not here\n HERE\n\n <<~BUT\\\n but\n BUT\n there\n" ├── content_loc: (5,0)-(13,0) = " way over\n <<HERE\n not here\n HERE\n\n <<~BUT\\\n but\n BUT\n there\n"
├── closing_loc: (100...106) = "THERE\n" ├── closing_loc: (14,0)-(14,0) = "THERE\n"
└── unescaped: "way over\n<<HERE\n not here\nHERE\n\n<<~BUT but\nBUT\n there\n" └── unescaped: "way over\n<<HERE\n not here\nHERE\n\n<<~BUT but\nBUT\n there\n"

12
test/yarp/snapshots/heredocs_with_ignored_newlines_and_non_empty.txt
View file

@ -1,11 +1,11 @@
@ ProgramNode (location: (0...6)) @ ProgramNode (location: (1,0)-(1,6))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...6)) @ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1) └── body: (length: 1)
└── @ StringNode (location: (0...6)) └── @ StringNode (location: (1,0)-(1,6))
├── flags: ∅ ├── flags: ∅
├── opening_loc: (0...6) = "<<-EOE" ├── opening_loc: (1,0)-(1,6) = "<<-EOE"
├── content_loc: (7...23) = " some\n heredocs\n" ├── content_loc: (2,0)-(3,0) = " some\n heredocs\n"
├── closing_loc: (23...26) = "EOE" ├── closing_loc: (4,0)-(4,3) = "EOE"
└── unescaped: " some\n heredocs\n" └── unescaped: " some\n heredocs\n"

348
test/yarp/snapshots/if.txt
View file

@ -1,129 +1,129 @@
@ ProgramNode (location: (0...382)) @ ProgramNode (location: (1,0)-(42,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...382)) @ StatementsNode (location: (1,0)-(42,3))
└── body: (length: 13) └── body: (length: 13)
├── @ IfNode (location: (0...15)) ├── @ IfNode (location: (1,0)-(1,15))
│ ├── if_keyword_loc: (0...2) = "if" │ ├── if_keyword_loc: (1,0)-(1,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (3...7)) │ │ @ TrueNode (location: (1,3)-(1,7))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (9...10)) │ │ @ StatementsNode (location: (1,9)-(1,10))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (9...10)) │ │ └── @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (12...15) = "end" │ └── end_keyword_loc: (1,12)-(1,15) = "end"
├── @ IfNode (location: (17...37)) ├── @ IfNode (location: (3,0)-(4,12))
│ ├── if_keyword_loc: (17...19) = "if" │ ├── if_keyword_loc: (3,0)-(3,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (20...24)) │ │ @ TrueNode (location: (3,3)-(3,7))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (25...26)) │ │ @ StatementsNode (location: (4,0)-(4,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (25...26)) │ │ └── @ IntegerNode (location: (4,0)-(4,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (27...37)) │ │ @ ElseNode (location: (4,2)-(4,12))
│ │ ├── else_keyword_loc: (27...31) = "else" │ │ ├── else_keyword_loc: (4,2)-(4,6) = "else"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (32...33)) │ │ │ @ StatementsNode (location: (4,7)-(4,8))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (32...33)) │ │ │ └── @ IntegerNode (location: (4,7)-(4,8))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── end_keyword_loc: (34...37) = "end" │ │ └── end_keyword_loc: (4,9)-(4,12) = "end"
│ └── end_keyword_loc: (34...37) = "end" │ └── end_keyword_loc: (4,9)-(4,12) = "end"
├── @ IfNode (location: (39...112)) ├── @ IfNode (location: (6,0)-(6,73))
│ ├── if_keyword_loc: (39...41) = "if" │ ├── if_keyword_loc: (6,0)-(6,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (42...46)) │ │ @ TrueNode (location: (6,3)-(6,7))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (52...56)) │ │ @ StatementsNode (location: (6,13)-(6,17))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ TrueNode (location: (52...56)) │ │ └── @ TrueNode (location: (6,13)-(6,17))
│ ├── consequent: │ ├── consequent:
│ │ @ IfNode (location: (57...112)) │ │ @ IfNode (location: (6,18)-(6,73))
│ │ ├── if_keyword_loc: (57...62) = "elsif" │ │ ├── if_keyword_loc: (6,18)-(6,23) = "elsif"
│ │ ├── predicate: │ │ ├── predicate:
│ │ │ @ FalseNode (location: (63...68)) │ │ │ @ FalseNode (location: (6,24)-(6,29))
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (74...79)) │ │ │ @ StatementsNode (location: (6,35)-(6,40))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ FalseNode (location: (74...79)) │ │ │ └── @ FalseNode (location: (6,35)-(6,40))
│ │ ├── consequent: │ │ ├── consequent:
│ │ │ @ IfNode (location: (80...112)) │ │ │ @ IfNode (location: (6,41)-(6,73))
│ │ │ ├── if_keyword_loc: (80...85) = "elsif" │ │ │ ├── if_keyword_loc: (6,41)-(6,46) = "elsif"
│ │ │ ├── predicate: │ │ │ ├── predicate:
│ │ │ │ @ NilNode (location: (86...89)) │ │ │ │ @ NilNode (location: (6,47)-(6,50))
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (95...98)) │ │ │ │ @ StatementsNode (location: (6,56)-(6,59))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ NilNode (location: (95...98)) │ │ │ │ └── @ NilNode (location: (6,56)-(6,59))
│ │ │ ├── consequent: │ │ │ ├── consequent:
│ │ │ │ @ ElseNode (location: (99...112)) │ │ │ │ @ ElseNode (location: (6,60)-(6,73))
│ │ │ │ ├── else_keyword_loc: (99...103) = "else" │ │ │ │ ├── else_keyword_loc: (6,60)-(6,64) = "else"
│ │ │ │ ├── statements: │ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (104...108)) │ │ │ │ │ @ StatementsNode (location: (6,65)-(6,69))
│ │ │ │ │ └── body: (length: 1) │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ SelfNode (location: (104...108)) │ │ │ │ │ └── @ SelfNode (location: (6,65)-(6,69))
│ │ │ │ └── end_keyword_loc: (109...112) = "end" │ │ │ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ │ │ └── end_keyword_loc: (109...112) = "end" │ │ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ │ └── end_keyword_loc: (109...112) = "end" │ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ └── end_keyword_loc: (109...112) = "end" │ └── end_keyword_loc: (6,70)-(6,73) = "end"
├── @ IfNode (location: (114...123)) ├── @ IfNode (location: (8,0)-(8,9))
│ ├── if_keyword_loc: (116...118) = "if" │ ├── if_keyword_loc: (8,2)-(8,4) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (119...123)) │ │ @ TrueNode (location: (8,5)-(8,9))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (114...115)) │ │ @ StatementsNode (location: (8,0)-(8,1))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (114...115)) │ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ IfNode (location: (125...138)) ├── @ IfNode (location: (10,0)-(10,13))
│ ├── if_keyword_loc: (131...133) = "if" │ ├── if_keyword_loc: (10,6)-(10,8) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (134...138)) │ │ @ TrueNode (location: (10,9)-(10,13))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (125...130)) │ │ @ StatementsNode (location: (10,0)-(10,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ BreakNode (location: (125...130)) │ │ └── @ BreakNode (location: (10,0)-(10,5))
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ └── keyword_loc: (125...130) = "break" │ │ └── keyword_loc: (10,0)-(10,5) = "break"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ IfNode (location: (140...152)) ├── @ IfNode (location: (12,0)-(12,12))
│ ├── if_keyword_loc: (145...147) = "if" │ ├── if_keyword_loc: (12,5)-(12,7) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (148...152)) │ │ @ TrueNode (location: (12,8)-(12,12))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (140...144)) │ │ @ StatementsNode (location: (12,0)-(12,4))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ NextNode (location: (140...144)) │ │ └── @ NextNode (location: (12,0)-(12,4))
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ └── keyword_loc: (140...144) = "next" │ │ └── keyword_loc: (12,0)-(12,4) = "next"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ IfNode (location: (154...168)) ├── @ IfNode (location: (14,0)-(14,14))
│ ├── if_keyword_loc: (161...163) = "if" │ ├── if_keyword_loc: (14,7)-(14,9) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (164...168)) │ │ @ TrueNode (location: (14,10)-(14,14))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (154...160)) │ │ @ StatementsNode (location: (14,0)-(14,6))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ReturnNode (location: (154...160)) │ │ └── @ ReturnNode (location: (14,0)-(14,6))
│ │ ├── keyword_loc: (154...160) = "return" │ │ ├── keyword_loc: (14,0)-(14,6) = "return"
│ │ └── arguments: ∅ │ │ └── arguments: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ IfNode (location: (170...200)) ├── @ IfNode (location: (16,0)-(16,30))
│ ├── if_keyword_loc: (170...172) = "if" │ ├── if_keyword_loc: (16,0)-(16,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ CallNode (location: (173...182)) │ │ @ CallNode (location: (16,3)-(16,12))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (173...182) = "exit_loop" │ │ ├── message_loc: (16,3)-(16,12) = "exit_loop"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -131,24 +131,24 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "exit_loop" │ │ └── name: "exit_loop"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (188...196)) │ │ @ StatementsNode (location: (16,18)-(16,26))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ BreakNode (location: (188...196)) │ │ └── @ BreakNode (location: (16,18)-(16,26))
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (194...196)) │ │ │ @ ArgumentsNode (location: (16,24)-(16,26))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (194...196)) │ │ │ └── @ IntegerNode (location: (16,24)-(16,26))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── keyword_loc: (188...193) = "break" │ │ └── keyword_loc: (16,18)-(16,23) = "break"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (197...200) = "end" │ └── end_keyword_loc: (16,27)-(16,30) = "end"
├── @ IfNode (location: (202...221)) ├── @ IfNode (location: (18,0)-(20,3))
│ ├── if_keyword_loc: (202...204) = "if" │ ├── if_keyword_loc: (18,0)-(18,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ CallNode (location: (205...208)) │ │ @ CallNode (location: (18,3)-(18,6))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (205...208) = "foo" │ │ ├── message_loc: (18,3)-(18,6) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -156,12 +156,12 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (214...217)) │ │ @ StatementsNode (location: (19,5)-(19,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (214...217)) │ │ └── @ CallNode (location: (19,5)-(19,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (214...217) = "bar" │ │ ├── message_loc: (19,5)-(19,8) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -169,14 +169,14 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (218...221) = "end" │ └── end_keyword_loc: (20,0)-(20,3) = "end"
├── @ IfNode (location: (223...234)) ├── @ IfNode (location: (22,0)-(22,11))
│ ├── if_keyword_loc: (230...232) = "if" │ ├── if_keyword_loc: (22,7)-(22,9) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ CallNode (location: (233...234)) │ │ @ CallNode (location: (22,10)-(22,11))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (233...234) = "c" │ │ ├── message_loc: (22,10)-(22,11) = "c"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -184,15 +184,15 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "c" │ │ └── name: "c"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (223...229)) │ │ @ StatementsNode (location: (22,0)-(22,6))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IfNode (location: (223...229)) │ │ └── @ IfNode (location: (22,0)-(22,6))
│ │ ├── if_keyword_loc: (225...227) = "if" │ │ ├── if_keyword_loc: (22,2)-(22,4) = "if"
│ │ ├── predicate: │ │ ├── predicate:
│ │ │ @ CallNode (location: (228...229)) │ │ │ @ CallNode (location: (22,5)-(22,6))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (228...229) = "b" │ │ │ ├── message_loc: (22,5)-(22,6) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -200,12 +200,12 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (223...224)) │ │ │ @ StatementsNode (location: (22,0)-(22,1))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (223...224)) │ │ │ └── @ CallNode (location: (22,0)-(22,1))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (223...224) = "a" │ │ │ ├── message_loc: (22,0)-(22,1) = "a"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -216,37 +216,37 @@
│ │ └── end_keyword_loc: ∅ │ │ └── end_keyword_loc: ∅
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ IfNode (location: (236...259)) ├── @ IfNode (location: (24,0)-(27,3))
│ ├── if_keyword_loc: (236...238) = "if" │ ├── if_keyword_loc: (24,0)-(24,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ TrueNode (location: (239...243)) │ │ @ TrueNode (location: (24,3)-(24,7))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (246...250)) │ │ @ StatementsNode (location: (25,2)-(25,6))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (246...250)) │ │ └── @ CallNode (location: (25,2)-(25,6))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (246...247) = "a" │ │ ├── message_loc: (25,2)-(25,3) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (248...250)) │ │ │ @ ArgumentsNode (location: (25,4)-(25,6))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ KeywordHashNode (location: (248...250)) │ │ │ └── @ KeywordHashNode (location: (25,4)-(25,6))
│ │ │ └── elements: (length: 1) │ │ │ └── elements: (length: 1)
│ │ │ └── @ AssocNode (location: (248...250)) │ │ │ └── @ AssocNode (location: (25,4)-(25,6))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (248...250)) │ │ │ │ @ SymbolNode (location: (25,4)-(25,6))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (248...249) = "b" │ │ │ │ ├── value_loc: (25,4)-(25,5) = "b"
│ │ │ │ ├── closing_loc: (249...250) = ":" │ │ │ │ ├── closing_loc: (25,5)-(25,6) = ":"
│ │ │ │ └── unescaped: "b" │ │ │ │ └── unescaped: "b"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (248...250)) │ │ │ │ @ ImplicitNode (location: (25,4)-(25,6))
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (248...250)) │ │ │ │ @ CallNode (location: (25,4)-(25,6))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (248...249) = "b" │ │ │ │ ├── message_loc: (25,4)-(25,5) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -259,20 +259,20 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "a" │ │ └── name: "a"
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (251...259)) │ │ @ ElseNode (location: (26,0)-(27,3))
│ │ ├── else_keyword_loc: (251...255) = "else" │ │ ├── else_keyword_loc: (26,0)-(26,4) = "else"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (256...259) = "end" │ │ └── end_keyword_loc: (27,0)-(27,3) = "end"
│ └── end_keyword_loc: (256...259) = "end" │ └── end_keyword_loc: (27,0)-(27,3) = "end"
├── @ IfNode (location: (261...293)) ├── @ IfNode (location: (29,0)-(31,3))
│ ├── if_keyword_loc: (261...263) = "if" │ ├── if_keyword_loc: (29,0)-(29,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ MatchPredicateNode (location: (264...273)) │ │ @ MatchPredicateNode (location: (29,3)-(29,12))
│ │ ├── value: │ │ ├── value:
│ │ │ @ CallNode (location: (264...268)) │ │ │ @ CallNode (location: (29,3)-(29,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (264...268) = "type" │ │ │ ├── message_loc: (29,3)-(29,7) = "type"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -280,20 +280,20 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "type" │ │ │ └── name: "type"
│ │ ├── pattern: │ │ ├── pattern:
│ │ │ @ IntegerNode (location: (272...273)) │ │ │ @ IntegerNode (location: (29,11)-(29,12))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── operator_loc: (269...271) = "in" │ │ └── operator_loc: (29,8)-(29,10) = "in"
│ ├── statements: ∅ │ ├── statements: ∅
│ ├── consequent: │ ├── consequent:
│ │ @ IfNode (location: (274...293)) │ │ @ IfNode (location: (30,0)-(31,3))
│ │ ├── if_keyword_loc: (274...279) = "elsif" │ │ ├── if_keyword_loc: (30,0)-(30,5) = "elsif"
│ │ ├── predicate: │ │ ├── predicate:
│ │ │ @ MatchPredicateNode (location: (280...289)) │ │ │ @ MatchPredicateNode (location: (30,6)-(30,15))
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ CallNode (location: (280...284)) │ │ │ │ @ CallNode (location: (30,6)-(30,10))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (280...284) = "type" │ │ │ │ ├── message_loc: (30,6)-(30,10) = "type"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -301,37 +301,37 @@
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "type" │ │ │ │ └── name: "type"
│ │ │ ├── pattern: │ │ │ ├── pattern:
│ │ │ │ @ ConstantReadNode (location: (288...289)) │ │ │ │ @ ConstantReadNode (location: (30,14)-(30,15))
│ │ │ │ └── name: :B │ │ │ │ └── name: :B
│ │ │ └── operator_loc: (285...287) = "in" │ │ │ └── operator_loc: (30,11)-(30,13) = "in"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ ├── consequent: ∅ │ │ ├── consequent: ∅
│ │ └── end_keyword_loc: (290...293) = "end" │ │ └── end_keyword_loc: (31,0)-(31,3) = "end"
│ └── end_keyword_loc: (290...293) = "end" │ └── end_keyword_loc: (31,0)-(31,3) = "end"
└── @ IfNode (location: (295...382)) └── @ IfNode (location: (33,0)-(42,3))
├── if_keyword_loc: (295...297) = "if" ├── if_keyword_loc: (33,0)-(33,2) = "if"
├── predicate: ├── predicate:
│ @ IntegerNode (location: (298...299)) │ @ IntegerNode (location: (33,3)-(33,4))
│ └── flags: decimal │ └── flags: decimal
├── statements: ├── statements:
│ @ StatementsNode (location: (302...321)) │ @ StatementsNode (location: (34,2)-(35,5))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (302...321)) │ └── @ CallNode (location: (34,2)-(35,5))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (302...308) = "lambda" │ ├── message_loc: (34,2)-(34,8) = "lambda"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (309...321)) │ │ @ BlockNode (location: (34,9)-(35,5))
│ │ ├── locals: [:_] │ │ ├── locals: [:_]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (312...315)) │ │ │ @ BlockParametersNode (location: (34,12)-(34,15))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (313...314)) │ │ │ │ @ ParametersNode (location: (34,13)-(34,14))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (313...314)) │ │ │ │ │ └── @ RequiredParameterNode (location: (34,13)-(34,14))
│ │ │ │ │ └── name: :_ │ │ │ │ │ └── name: :_
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -340,38 +340,38 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (312...313) = "|" │ │ │ ├── opening_loc: (34,12)-(34,13) = "|"
│ │ │ └── closing_loc: (314...315) = "|" │ │ │ └── closing_loc: (34,14)-(34,15) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (309...311) = "do" │ │ ├── opening_loc: (34,9)-(34,11) = "do"
│ │ └── closing_loc: (318...321) = "end" │ │ └── closing_loc: (35,2)-(35,5) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "lambda" │ └── name: "lambda"
├── consequent: ├── consequent:
│ @ IfNode (location: (322...382)) │ @ IfNode (location: (36,0)-(42,3))
│ ├── if_keyword_loc: (322...327) = "elsif" │ ├── if_keyword_loc: (36,0)-(36,5) = "elsif"
│ ├── predicate: │ ├── predicate:
│ │ @ IntegerNode (location: (328...329)) │ │ @ IntegerNode (location: (36,6)-(36,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (332...351)) │ │ @ StatementsNode (location: (37,2)-(38,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (332...351)) │ │ └── @ CallNode (location: (37,2)-(38,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (332...338) = "lambda" │ │ ├── message_loc: (37,2)-(37,8) = "lambda"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: │ │ ├── block:
│ │ │ @ BlockNode (location: (339...351)) │ │ │ @ BlockNode (location: (37,9)-(38,5))
│ │ │ ├── locals: [:_] │ │ │ ├── locals: [:_]
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ BlockParametersNode (location: (342...345)) │ │ │ │ @ BlockParametersNode (location: (37,12)-(37,15))
│ │ │ │ ├── parameters: │ │ │ │ ├── parameters:
│ │ │ │ │ @ ParametersNode (location: (343...344)) │ │ │ │ │ @ ParametersNode (location: (37,13)-(37,14))
│ │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ │ └── @ RequiredParameterNode (location: (343...344)) │ │ │ │ │ │ └── @ RequiredParameterNode (location: (37,13)-(37,14))
│ │ │ │ │ │ └── name: :_ │ │ │ │ │ │ └── name: :_
│ │ │ │ │ ├── optionals: (length: 0) │ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ ├── rest: ∅ │ │ │ │ │ ├── rest: ∅
@ -380,35 +380,35 @@
│ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ └── block: ∅ │ │ │ │ │ └── block: ∅
│ │ │ │ ├── locals: (length: 0) │ │ │ │ ├── locals: (length: 0)
│ │ │ │ ├── opening_loc: (342...343) = "|" │ │ │ │ ├── opening_loc: (37,12)-(37,13) = "|"
│ │ │ │ └── closing_loc: (344...345) = "|" │ │ │ │ └── closing_loc: (37,14)-(37,15) = "|"
│ │ │ ├── body: ∅ │ │ │ ├── body: ∅
│ │ │ ├── opening_loc: (339...341) = "do" │ │ │ ├── opening_loc: (37,9)-(37,11) = "do"
│ │ │ └── closing_loc: (348...351) = "end" │ │ │ └── closing_loc: (38,2)-(38,5) = "end"
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "lambda" │ │ └── name: "lambda"
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (352...382)) │ │ @ ElseNode (location: (39,0)-(42,3))
│ │ ├── else_keyword_loc: (352...356) = "else" │ │ ├── else_keyword_loc: (39,0)-(39,4) = "else"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (359...378)) │ │ │ @ StatementsNode (location: (40,2)-(41,5))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (359...378)) │ │ │ └── @ CallNode (location: (40,2)-(41,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (359...365) = "lambda" │ │ │ ├── message_loc: (40,2)-(40,8) = "lambda"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: │ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (366...378)) │ │ │ │ @ BlockNode (location: (40,9)-(41,5))
│ │ │ │ ├── locals: [:_] │ │ │ │ ├── locals: [:_]
│ │ │ │ ├── parameters: │ │ │ │ ├── parameters:
│ │ │ │ │ @ BlockParametersNode (location: (369...372)) │ │ │ │ │ @ BlockParametersNode (location: (40,12)-(40,15))
│ │ │ │ │ ├── parameters: │ │ │ │ │ ├── parameters:
│ │ │ │ │ │ @ ParametersNode (location: (370...371)) │ │ │ │ │ │ @ ParametersNode (location: (40,13)-(40,14))
│ │ │ │ │ │ ├── requireds: (length: 1) │ │ │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ │ │ └── @ RequiredParameterNode (location: (370...371)) │ │ │ │ │ │ │ └── @ RequiredParameterNode (location: (40,13)-(40,14))
│ │ │ │ │ │ │ └── name: :_ │ │ │ │ │ │ │ └── name: :_
│ │ │ │ │ │ ├── optionals: (length: 0) │ │ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ │ ├── rest: ∅ │ │ │ │ │ │ ├── rest: ∅
@ -417,13 +417,13 @@
│ │ │ │ │ │ ├── keyword_rest: ∅ │ │ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ │ └── block: ∅ │ │ │ │ │ │ └── block: ∅
│ │ │ │ │ ├── locals: (length: 0) │ │ │ │ │ ├── locals: (length: 0)
│ │ │ │ │ ├── opening_loc: (369...370) = "|" │ │ │ │ │ ├── opening_loc: (40,12)-(40,13) = "|"
│ │ │ │ │ └── closing_loc: (371...372) = "|" │ │ │ │ │ └── closing_loc: (40,14)-(40,15) = "|"
│ │ │ │ ├── body: ∅ │ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (366...368) = "do" │ │ │ │ ├── opening_loc: (40,9)-(40,11) = "do"
│ │ │ │ └── closing_loc: (375...378) = "end" │ │ │ │ └── closing_loc: (41,2)-(41,5) = "end"
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "lambda" │ │ │ └── name: "lambda"
│ │ └── end_keyword_loc: (379...382) = "end" │ │ └── end_keyword_loc: (42,0)-(42,3) = "end"
│ └── end_keyword_loc: (379...382) = "end" │ └── end_keyword_loc: (42,0)-(42,3) = "end"
└── end_keyword_loc: (379...382) = "end" └── end_keyword_loc: (42,0)-(42,3) = "end"

12
test/yarp/snapshots/indented_file_end.txt
View file

@ -1,18 +1,18 @@
@ ProgramNode (location: (4...23)) @ ProgramNode (location: (1,4)-(3,7))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (4...23)) @ StatementsNode (location: (1,4)-(3,7))
└── body: (length: 1) └── body: (length: 1)
└── @ DefNode (location: (4...23)) └── @ DefNode (location: (1,4)-(3,7))
├── name: :hi ├── name: :hi
├── name_loc: (8...10) = "hi" ├── name_loc: (1,8)-(1,10) = "hi"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ∅ ├── parameters: ∅
├── body: ∅ ├── body: ∅
├── locals: [] ├── locals: []
├── def_keyword_loc: (4...7) = "def" ├── def_keyword_loc: (1,4)-(1,7) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── rparen_loc: ∅ ├── rparen_loc: ∅
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (20...23) = "end" └── end_keyword_loc: (3,4)-(3,7) = "end"

348
test/yarp/snapshots/integer_operations.txt
View file

@ -1,435 +1,435 @@
@ ProgramNode (location: (0...247)) @ ProgramNode (location: (1,0)-(63,7))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...247)) @ StatementsNode (location: (1,0)-(63,7))
└── body: (length: 32) └── body: (length: 32)
├── @ CallNode (location: (0...2)) ├── @ CallNode (location: (1,0)-(1,2))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (1...2)) │ │ @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "!" │ ├── message_loc: (1,0)-(1,1) = "!"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
├── @ CallNode (location: (4...6)) ├── @ CallNode (location: (3,0)-(3,2))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (5...6)) │ │ @ IntegerNode (location: (3,1)-(3,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (4...5) = "~" │ ├── message_loc: (3,0)-(3,1) = "~"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "~" │ └── name: "~"
├── @ CallNode (location: (8...14)) ├── @ CallNode (location: (5,0)-(5,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (8...9)) │ │ @ IntegerNode (location: (5,0)-(5,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (10...12) = "!=" │ ├── message_loc: (5,2)-(5,4) = "!="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (13...14)) │ │ @ ArgumentsNode (location: (5,5)-(5,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (13...14)) │ │ └── @ IntegerNode (location: (5,5)-(5,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!=" │ └── name: "!="
├── @ CallNode (location: (16...22)) ├── @ CallNode (location: (7,0)-(7,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (16...17)) │ │ @ IntegerNode (location: (7,0)-(7,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (18...20) = "!~" │ ├── message_loc: (7,2)-(7,4) = "!~"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (21...22)) │ │ @ ArgumentsNode (location: (7,5)-(7,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (21...22)) │ │ └── @ IntegerNode (location: (7,5)-(7,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!~" │ └── name: "!~"
├── @ CallNode (location: (24...29)) ├── @ CallNode (location: (9,0)-(9,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (24...25)) │ │ @ IntegerNode (location: (9,0)-(9,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (26...27) = "%" │ ├── message_loc: (9,2)-(9,3) = "%"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (28...29)) │ │ @ ArgumentsNode (location: (9,4)-(9,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (28...29)) │ │ └── @ IntegerNode (location: (9,4)-(9,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "%" │ └── name: "%"
├── @ CallNode (location: (31...36)) ├── @ CallNode (location: (11,0)-(11,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (31...32)) │ │ @ IntegerNode (location: (11,0)-(11,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (33...34) = "&" │ ├── message_loc: (11,2)-(11,3) = "&"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (35...36)) │ │ @ ArgumentsNode (location: (11,4)-(11,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (35...36)) │ │ └── @ IntegerNode (location: (11,4)-(11,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "&" │ └── name: "&"
├── @ CallNode (location: (38...43)) ├── @ CallNode (location: (13,0)-(13,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (38...39)) │ │ @ IntegerNode (location: (13,0)-(13,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (40...41) = "*" │ ├── message_loc: (13,2)-(13,3) = "*"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (42...43)) │ │ @ ArgumentsNode (location: (13,4)-(13,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (42...43)) │ │ └── @ IntegerNode (location: (13,4)-(13,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "*" │ └── name: "*"
├── @ CallNode (location: (45...49)) ├── @ CallNode (location: (15,0)-(15,4))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (45...46)) │ │ @ IntegerNode (location: (15,0)-(15,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (46...48) = "**" │ ├── message_loc: (15,1)-(15,3) = "**"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (48...49)) │ │ @ ArgumentsNode (location: (15,3)-(15,4))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (48...49)) │ │ └── @ IntegerNode (location: (15,3)-(15,4))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "**" │ └── name: "**"
├── @ CallNode (location: (51...56)) ├── @ CallNode (location: (17,0)-(17,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (51...52)) │ │ @ IntegerNode (location: (17,0)-(17,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (53...54) = "+" │ ├── message_loc: (17,2)-(17,3) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (55...56)) │ │ @ ArgumentsNode (location: (17,4)-(17,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (55...56)) │ │ └── @ IntegerNode (location: (17,4)-(17,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
├── @ CallNode (location: (58...63)) ├── @ CallNode (location: (19,0)-(19,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (58...59)) │ │ @ IntegerNode (location: (19,0)-(19,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (60...61) = "-" │ ├── message_loc: (19,2)-(19,3) = "-"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (62...63)) │ │ @ ArgumentsNode (location: (19,4)-(19,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (62...63)) │ │ └── @ IntegerNode (location: (19,4)-(19,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "-" │ └── name: "-"
├── @ CallNode (location: (65...70)) ├── @ CallNode (location: (21,0)-(21,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (65...66)) │ │ @ IntegerNode (location: (21,0)-(21,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (67...68) = "/" │ ├── message_loc: (21,2)-(21,3) = "/"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (69...70)) │ │ @ ArgumentsNode (location: (21,4)-(21,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (69...70)) │ │ └── @ IntegerNode (location: (21,4)-(21,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "/" │ └── name: "/"
├── @ CallNode (location: (72...77)) ├── @ CallNode (location: (23,0)-(23,5))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (72...75)) │ │ @ CallNode (location: (23,0)-(23,3))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (72...73)) │ │ │ @ IntegerNode (location: (23,0)-(23,1))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (73...74) = "/" │ │ ├── message_loc: (23,1)-(23,2) = "/"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (74...75)) │ │ │ @ ArgumentsNode (location: (23,2)-(23,3))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (74...75)) │ │ │ └── @ IntegerNode (location: (23,2)-(23,3))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "/" │ │ └── name: "/"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (75...76) = "/" │ ├── message_loc: (23,3)-(23,4) = "/"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (76...77)) │ │ @ ArgumentsNode (location: (23,4)-(23,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (76...77)) │ │ └── @ IntegerNode (location: (23,4)-(23,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "/" │ └── name: "/"
├── @ CallNode (location: (79...84)) ├── @ CallNode (location: (25,0)-(25,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (79...80)) │ │ @ IntegerNode (location: (25,0)-(25,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (81...82) = "<" │ ├── message_loc: (25,2)-(25,3) = "<"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (83...84)) │ │ @ ArgumentsNode (location: (25,4)-(25,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (83...84)) │ │ └── @ IntegerNode (location: (25,4)-(25,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "<" │ └── name: "<"
├── @ CallNode (location: (86...92)) ├── @ CallNode (location: (27,0)-(27,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (86...87)) │ │ @ IntegerNode (location: (27,0)-(27,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (88...90) = "<<" │ ├── message_loc: (27,2)-(27,4) = "<<"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (91...92)) │ │ @ ArgumentsNode (location: (27,5)-(27,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (91...92)) │ │ └── @ IntegerNode (location: (27,5)-(27,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "<<" │ └── name: "<<"
├── @ CallNode (location: (94...100)) ├── @ CallNode (location: (29,0)-(29,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (94...95)) │ │ @ IntegerNode (location: (29,0)-(29,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (96...98) = "<=" │ ├── message_loc: (29,2)-(29,4) = "<="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (99...100)) │ │ @ ArgumentsNode (location: (29,5)-(29,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (99...100)) │ │ └── @ IntegerNode (location: (29,5)-(29,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "<=" │ └── name: "<="
├── @ CallNode (location: (102...109)) ├── @ CallNode (location: (31,0)-(31,7))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (102...103)) │ │ @ IntegerNode (location: (31,0)-(31,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (104...107) = "<=>" │ ├── message_loc: (31,2)-(31,5) = "<=>"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (108...109)) │ │ @ ArgumentsNode (location: (31,6)-(31,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (108...109)) │ │ └── @ IntegerNode (location: (31,6)-(31,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "<=>" │ └── name: "<=>"
├── @ CallNode (location: (111...117)) ├── @ CallNode (location: (33,0)-(33,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (111...112)) │ │ @ IntegerNode (location: (33,0)-(33,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (113...115) = "==" │ ├── message_loc: (33,2)-(33,4) = "=="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (116...117)) │ │ @ ArgumentsNode (location: (33,5)-(33,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (116...117)) │ │ └── @ IntegerNode (location: (33,5)-(33,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "==" │ └── name: "=="
├── @ CallNode (location: (119...126)) ├── @ CallNode (location: (35,0)-(35,7))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (119...120)) │ │ @ IntegerNode (location: (35,0)-(35,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (121...124) = "===" │ ├── message_loc: (35,2)-(35,5) = "==="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (125...126)) │ │ @ ArgumentsNode (location: (35,6)-(35,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (125...126)) │ │ └── @ IntegerNode (location: (35,6)-(35,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "===" │ └── name: "==="
├── @ CallNode (location: (128...134)) ├── @ CallNode (location: (37,0)-(37,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (128...129)) │ │ @ IntegerNode (location: (37,0)-(37,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (130...132) = "=~" │ ├── message_loc: (37,2)-(37,4) = "=~"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (133...134)) │ │ @ ArgumentsNode (location: (37,5)-(37,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (133...134)) │ │ └── @ IntegerNode (location: (37,5)-(37,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "=~" │ └── name: "=~"
├── @ CallNode (location: (136...141)) ├── @ CallNode (location: (39,0)-(39,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (136...137)) │ │ @ IntegerNode (location: (39,0)-(39,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (138...139) = ">" │ ├── message_loc: (39,2)-(39,3) = ">"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (140...141)) │ │ @ ArgumentsNode (location: (39,4)-(39,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (140...141)) │ │ └── @ IntegerNode (location: (39,4)-(39,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: ">" │ └── name: ">"
├── @ CallNode (location: (143...149)) ├── @ CallNode (location: (41,0)-(41,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (143...144)) │ │ @ IntegerNode (location: (41,0)-(41,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (145...147) = ">=" │ ├── message_loc: (41,2)-(41,4) = ">="
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (148...149)) │ │ @ ArgumentsNode (location: (41,5)-(41,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (148...149)) │ │ └── @ IntegerNode (location: (41,5)-(41,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: ">=" │ └── name: ">="
├── @ CallNode (location: (151...157)) ├── @ CallNode (location: (43,0)-(43,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (151...152)) │ │ @ IntegerNode (location: (43,0)-(43,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (153...155) = ">>" │ ├── message_loc: (43,2)-(43,4) = ">>"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (156...157)) │ │ @ ArgumentsNode (location: (43,5)-(43,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (156...157)) │ │ └── @ IntegerNode (location: (43,5)-(43,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: ">>" │ └── name: ">>"
├── @ CallNode (location: (159...164)) ├── @ CallNode (location: (45,0)-(45,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (159...160)) │ │ @ IntegerNode (location: (45,0)-(45,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (161...162) = "^" │ ├── message_loc: (45,2)-(45,3) = "^"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (163...164)) │ │ @ ArgumentsNode (location: (45,4)-(45,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (163...164)) │ │ └── @ IntegerNode (location: (45,4)-(45,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "^" │ └── name: "^"
├── @ CallNode (location: (166...171)) ├── @ CallNode (location: (47,0)-(47,5))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (166...167)) │ │ @ IntegerNode (location: (47,0)-(47,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (168...169) = "|" │ ├── message_loc: (47,2)-(47,3) = "|"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (170...171)) │ │ @ ArgumentsNode (location: (47,4)-(47,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (170...171)) │ │ └── @ IntegerNode (location: (47,4)-(47,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "|" │ └── name: "|"
├── @ AndNode (location: (173...179)) ├── @ AndNode (location: (49,0)-(49,6))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (173...174)) │ │ @ IntegerNode (location: (49,0)-(49,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (178...179)) │ │ @ IntegerNode (location: (49,5)-(49,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (175...177) = "&&" │ └── operator_loc: (49,2)-(49,4) = "&&"
├── @ AndNode (location: (181...188)) ├── @ AndNode (location: (51,0)-(51,7))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (181...182)) │ │ @ IntegerNode (location: (51,0)-(51,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (187...188)) │ │ @ IntegerNode (location: (51,6)-(51,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (183...186) = "and" │ └── operator_loc: (51,2)-(51,5) = "and"
├── @ CallNode (location: (190...200)) ├── @ CallNode (location: (53,0)-(53,10))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (190...191)) │ │ @ IntegerNode (location: (53,0)-(53,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (192...193) = "*" │ ├── message_loc: (53,2)-(53,3) = "*"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (194...200)) │ │ @ ArgumentsNode (location: (53,4)-(53,10))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (194...200)) │ │ └── @ CallNode (location: (53,4)-(53,10))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (194...195)) │ │ │ @ IntegerNode (location: (53,4)-(53,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (196...198) = "**" │ │ ├── message_loc: (53,6)-(53,8) = "**"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (199...200)) │ │ │ @ ArgumentsNode (location: (53,9)-(53,10))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (199...200)) │ │ │ └── @ IntegerNode (location: (53,9)-(53,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
@ -439,73 +439,73 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "*" │ └── name: "*"
├── @ CallNode (location: (202...211)) ├── @ CallNode (location: (55,0)-(55,9))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (202...207)) │ │ @ CallNode (location: (55,0)-(55,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (202...203)) │ │ │ @ IntegerNode (location: (55,0)-(55,1))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (204...205) = "*" │ │ ├── message_loc: (55,2)-(55,3) = "*"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (206...207)) │ │ │ @ ArgumentsNode (location: (55,4)-(55,5))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (206...207)) │ │ │ └── @ IntegerNode (location: (55,4)-(55,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "*" │ │ └── name: "*"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (208...209) = "+" │ ├── message_loc: (55,6)-(55,7) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (210...211)) │ │ @ ArgumentsNode (location: (55,8)-(55,9))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (210...211)) │ │ └── @ IntegerNode (location: (55,8)-(55,9))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
├── @ OrNode (location: (213...219)) ├── @ OrNode (location: (57,0)-(57,6))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (213...214)) │ │ @ IntegerNode (location: (57,0)-(57,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (218...219)) │ │ @ IntegerNode (location: (57,5)-(57,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (215...217) = "or" │ └── operator_loc: (57,2)-(57,4) = "or"
├── @ OrNode (location: (221...227)) ├── @ OrNode (location: (59,0)-(59,6))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (221...222)) │ │ @ IntegerNode (location: (59,0)-(59,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (226...227)) │ │ @ IntegerNode (location: (59,5)-(59,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (223...225) = "||" │ └── operator_loc: (59,2)-(59,4) = "||"
├── @ CallNode (location: (229...238)) ├── @ CallNode (location: (61,0)-(61,9))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (229...230)) │ │ @ IntegerNode (location: (61,0)-(61,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (231...232) = "+" │ ├── message_loc: (61,2)-(61,3) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (233...238)) │ │ @ ArgumentsNode (location: (61,4)-(61,9))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (233...238)) │ │ └── @ CallNode (location: (61,4)-(61,9))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ IntegerNode (location: (233...234)) │ │ │ @ IntegerNode (location: (61,4)-(61,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (235...236) = "*" │ │ ├── message_loc: (61,6)-(61,7) = "*"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (237...238)) │ │ │ @ ArgumentsNode (location: (61,8)-(61,9))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (237...238)) │ │ │ └── @ IntegerNode (location: (61,8)-(61,9))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
@ -515,25 +515,25 @@
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
└── @ ParenthesesNode (location: (240...247)) └── @ ParenthesesNode (location: (63,0)-(63,7))
├── body: ├── body:
│ @ StatementsNode (location: (241...246)) │ @ StatementsNode (location: (63,1)-(63,6))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (241...246)) │ └── @ CallNode (location: (63,1)-(63,6))
│ ├── receiver: │ ├── receiver:
│ │ @ IntegerNode (location: (241...242)) │ │ @ IntegerNode (location: (63,1)-(63,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (243...244) = "+" │ ├── message_loc: (63,3)-(63,4) = "+"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (245...246)) │ │ @ ArgumentsNode (location: (63,5)-(63,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (245...246)) │ │ └── @ IntegerNode (location: (63,5)-(63,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "+" │ └── name: "+"
├── opening_loc: (240...241) = "(" ├── opening_loc: (63,0)-(63,1) = "("
└── closing_loc: (246...247) = ")" └── closing_loc: (63,6)-(63,7) = ")"

136
test/yarp/snapshots/keyword_method_names.txt
View file

@ -1,170 +1,170 @@
@ ProgramNode (location: (0...185)) @ ProgramNode (location: (1,0)-(29,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...185)) @ StatementsNode (location: (1,0)-(29,3))
└── body: (length: 10) └── body: (length: 10)
├── @ DefNode (location: (0...11)) ├── @ DefNode (location: (1,0)-(2,3))
│ ├── name: :def │ ├── name: :def
│ ├── name_loc: (4...7) = "def" │ ├── name_loc: (1,4)-(1,7) = "def"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def" │ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (8...11) = "end" │ └── end_keyword_loc: (2,0)-(2,3) = "end"
├── @ DefNode (location: (13...32)) ├── @ DefNode (location: (4,0)-(5,3))
│ ├── name: :ensure │ ├── name: :ensure
│ ├── name_loc: (22...28) = "ensure" │ ├── name_loc: (4,9)-(4,15) = "ensure"
│ ├── receiver: │ ├── receiver:
│ │ @ SelfNode (location: (17...21)) │ │ @ SelfNode (location: (4,4)-(4,8))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (13...16) = "def" │ ├── def_keyword_loc: (4,0)-(4,3) = "def"
│ ├── operator_loc: (21...22) = "." │ ├── operator_loc: (4,8)-(4,9) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (29...32) = "end" │ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ CallNode (location: (34...68)) ├── @ CallNode (location: (7,0)-(10,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (34...41) = "private" │ ├── message_loc: (7,0)-(7,7) = "private"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (42...68)) │ │ @ ArgumentsNode (location: (7,8)-(10,3))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ DefNode (location: (42...68)) │ │ └── @ DefNode (location: (7,8)-(10,3))
│ │ ├── name: :foo │ │ ├── name: :foo
│ │ ├── name_loc: (46...49) = "foo" │ │ ├── name_loc: (7,12)-(7,15) = "foo"
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (52...64)) │ │ │ @ StatementsNode (location: (8,2)-(9,5))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (52...64)) │ │ │ └── @ CallNode (location: (8,2)-(9,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (52...55) = "bar" │ │ │ ├── message_loc: (8,2)-(8,5) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: │ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (56...64)) │ │ │ │ @ BlockNode (location: (8,6)-(9,5))
│ │ │ │ ├── locals: [] │ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅ │ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body: ∅ │ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (56...58) = "do" │ │ │ │ ├── opening_loc: (8,6)-(8,8) = "do"
│ │ │ │ └── closing_loc: (61...64) = "end" │ │ │ │ └── closing_loc: (9,2)-(9,5) = "end"
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── def_keyword_loc: (42...45) = "def" │ │ ├── def_keyword_loc: (7,8)-(7,11) = "def"
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: ∅ │ │ ├── lparen_loc: ∅
│ │ ├── rparen_loc: ∅ │ │ ├── rparen_loc: ∅
│ │ ├── equal_loc: ∅ │ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (65...68) = "end" │ │ └── end_keyword_loc: (10,0)-(10,3) = "end"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "private" │ └── name: "private"
├── @ DefNode (location: (70...89)) ├── @ DefNode (location: (12,0)-(13,3))
│ ├── name: :m │ ├── name: :m
│ ├── name_loc: (74...75) = "m" │ ├── name_loc: (12,4)-(12,5) = "m"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: │ ├── parameters:
│ │ @ ParametersNode (location: (76...84)) │ │ @ ParametersNode (location: (12,6)-(12,14))
│ │ ├── requireds: (length: 1) │ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredParameterNode (location: (76...77)) │ │ │ └── @ RequiredParameterNode (location: (12,6)-(12,7))
│ │ │ └── name: :a │ │ │ └── name: :a
│ │ ├── optionals: (length: 0) │ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅ │ │ ├── rest: ∅
│ │ ├── posts: (length: 0) │ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0) │ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest: │ │ ├── keyword_rest:
│ │ │ @ NoKeywordsParameterNode (location: (79...84)) │ │ │ @ NoKeywordsParameterNode (location: (12,9)-(12,14))
│ │ │ ├── operator_loc: (79...81) = "**" │ │ │ ├── operator_loc: (12,9)-(12,11) = "**"
│ │ │ └── keyword_loc: (81...84) = "nil" │ │ │ └── keyword_loc: (12,11)-(12,14) = "nil"
│ │ └── block: ∅ │ │ └── block: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── def_keyword_loc: (70...73) = "def" │ ├── def_keyword_loc: (12,0)-(12,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: (75...76) = "(" │ ├── lparen_loc: (12,5)-(12,6) = "("
│ ├── rparen_loc: (84...85) = ")" │ ├── rparen_loc: (12,14)-(12,15) = ")"
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (86...89) = "end" │ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ DefNode (location: (91...113)) ├── @ DefNode (location: (15,0)-(16,3))
│ ├── name: :a │ ├── name: :a
│ ├── name_loc: (108...109) = "a" │ ├── name_loc: (15,17)-(15,18) = "a"
│ ├── receiver: │ ├── receiver:
│ │ @ SourceEncodingNode (location: (95...107)) │ │ @ SourceEncodingNode (location: (15,4)-(15,16))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (91...94) = "def" │ ├── def_keyword_loc: (15,0)-(15,3) = "def"
│ ├── operator_loc: (107...108) = "." │ ├── operator_loc: (15,16)-(15,17) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (110...113) = "end" │ └── end_keyword_loc: (16,0)-(16,3) = "end"
├── @ StringNode (location: (115...121)) ├── @ StringNode (location: (18,0)-(18,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (115...117) = "%{" │ ├── opening_loc: (18,0)-(18,2) = "%{"
│ ├── content_loc: (117...120) = "abc" │ ├── content_loc: (18,2)-(18,5) = "abc"
│ ├── closing_loc: (120...121) = "}" │ ├── closing_loc: (18,5)-(18,6) = "}"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (123...129)) ├── @ StringNode (location: (20,0)-(20,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (123...125) = "%\"" │ ├── opening_loc: (20,0)-(20,2) = "%\""
│ ├── content_loc: (125...128) = "abc" │ ├── content_loc: (20,2)-(20,5) = "abc"
│ ├── closing_loc: (128...129) = "\"" │ ├── closing_loc: (20,5)-(20,6) = "\""
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ DefNode (location: (131...149)) ├── @ DefNode (location: (22,0)-(23,3))
│ ├── name: :a │ ├── name: :a
│ ├── name_loc: (144...145) = "a" │ ├── name_loc: (22,13)-(22,14) = "a"
│ ├── receiver: │ ├── receiver:
│ │ @ SourceFileNode (location: (135...143)) │ │ @ SourceFileNode (location: (22,4)-(22,12))
│ │ └── filepath: "keyword_method_names.txt" │ │ └── filepath: "keyword_method_names.txt"
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (131...134) = "def" │ ├── def_keyword_loc: (22,0)-(22,3) = "def"
│ ├── operator_loc: (143...144) = "." │ ├── operator_loc: (22,12)-(22,13) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (146...149) = "end" │ └── end_keyword_loc: (23,0)-(23,3) = "end"
├── @ DefNode (location: (151...169)) ├── @ DefNode (location: (25,0)-(26,3))
│ ├── name: :a │ ├── name: :a
│ ├── name_loc: (164...165) = "a" │ ├── name_loc: (25,13)-(25,14) = "a"
│ ├── receiver: │ ├── receiver:
│ │ @ SourceLineNode (location: (155...163)) │ │ @ SourceLineNode (location: (25,4)-(25,12))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (151...154) = "def" │ ├── def_keyword_loc: (25,0)-(25,3) = "def"
│ ├── operator_loc: (163...164) = "." │ ├── operator_loc: (25,12)-(25,13) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (166...169) = "end" │ └── end_keyword_loc: (26,0)-(26,3) = "end"
└── @ DefNode (location: (171...185)) └── @ DefNode (location: (28,0)-(29,3))
├── name: :a ├── name: :a
├── name_loc: (180...181) = "a" ├── name_loc: (28,9)-(28,10) = "a"
├── receiver: ├── receiver:
│ @ NilNode (location: (175...178)) │ @ NilNode (location: (28,4)-(28,7))
├── parameters: ∅ ├── parameters: ∅
├── body: ∅ ├── body: ∅
├── locals: [] ├── locals: []
├── def_keyword_loc: (171...174) = "def" ├── def_keyword_loc: (28,0)-(28,3) = "def"
├── operator_loc: (178...180) = "::" ├── operator_loc: (28,7)-(28,9) = "::"
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── rparen_loc: ∅ ├── rparen_loc: ∅
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (182...185) = "end" └── end_keyword_loc: (29,0)-(29,3) = "end"

16
test/yarp/snapshots/keywords.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...51)) @ ProgramNode (location: (1,0)-(11,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...51)) @ StatementsNode (location: (1,0)-(11,8))
└── body: (length: 6) └── body: (length: 6)
├── @ RedoNode (location: (0...4)) ├── @ RedoNode (location: (1,0)-(1,4))
├── @ RetryNode (location: (6...11)) ├── @ RetryNode (location: (3,0)-(3,5))
├── @ SelfNode (location: (13...17)) ├── @ SelfNode (location: (5,0)-(5,4))
├── @ SourceEncodingNode (location: (19...31)) ├── @ SourceEncodingNode (location: (7,0)-(7,12))
├── @ SourceFileNode (location: (33...41)) ├── @ SourceFileNode (location: (9,0)-(9,8))
│ └── filepath: "keywords.txt" │ └── filepath: "keywords.txt"
└── @ SourceLineNode (location: (43...51)) └── @ SourceLineNode (location: (11,0)-(11,8))

138
test/yarp/snapshots/lambda.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...92)) @ ProgramNode (location: (1,0)-(11,18))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...92)) @ StatementsNode (location: (1,0)-(11,18))
└── body: (length: 5) └── body: (length: 5)
├── @ LambdaNode (location: (0...14)) ├── @ LambdaNode (location: (1,0)-(3,4))
│ ├── locals: [:foo] │ ├── locals: [:foo]
│ ├── operator_loc: (0...2) = "->" │ ├── operator_loc: (1,0)-(1,2) = "->"
│ ├── opening_loc: (12...13) = "{" │ ├── opening_loc: (3,2)-(3,3) = "{"
│ ├── closing_loc: (13...14) = "}" │ ├── closing_loc: (3,3)-(3,4) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (2...11)) │ │ @ BlockParametersNode (location: (1,2)-(3,1))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (6...9)) │ │ │ @ ParametersNode (location: (2,2)-(2,5))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (6...9)) │ │ │ │ └── @ RequiredParameterNode (location: (2,2)-(2,5))
│ │ │ │ └── name: :foo │ │ │ │ └── name: :foo
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -22,83 +22,83 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (2...3) = "(" │ │ ├── opening_loc: (1,2)-(1,3) = "("
│ │ └── closing_loc: (10...11) = ")" │ │ └── closing_loc: (3,0)-(3,1) = ")"
│ └── body: ∅ │ └── body: ∅
├── @ LambdaNode (location: (16...34)) ├── @ LambdaNode (location: (5,0)-(5,18))
│ ├── locals: [:x] │ ├── locals: [:x]
│ ├── operator_loc: (16...18) = "->" │ ├── operator_loc: (5,0)-(5,2) = "->"
│ ├── opening_loc: (31...32) = "{" │ ├── opening_loc: (5,15)-(5,16) = "{"
│ ├── closing_loc: (33...34) = "}" │ ├── closing_loc: (5,17)-(5,18) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (18...30)) │ │ @ BlockParametersNode (location: (5,2)-(5,14))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (19...29)) │ │ │ @ ParametersNode (location: (5,3)-(5,13))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 1) │ │ │ ├── keywords: (length: 1)
│ │ │ │ └── @ KeywordParameterNode (location: (19...29)) │ │ │ │ └── @ KeywordParameterNode (location: (5,3)-(5,13))
│ │ │ │ ├── name: :x │ │ │ │ ├── name: :x
│ │ │ │ ├── name_loc: (19...21) = "x:" │ │ │ │ ├── name_loc: (5,3)-(5,5) = "x:"
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ InterpolatedStringNode (location: (22...29)) │ │ │ │ @ InterpolatedStringNode (location: (5,6)-(5,13))
│ │ │ │ ├── opening_loc: (22...23) = "\"" │ │ │ │ ├── opening_loc: (5,6)-(5,7) = "\""
│ │ │ │ ├── parts: (length: 2) │ │ │ │ ├── parts: (length: 2)
│ │ │ │ │ ├── @ StringNode (location: (23...24)) │ │ │ │ │ ├── @ StringNode (location: (5,7)-(5,8))
│ │ │ │ │ │ ├── flags: ∅ │ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── content_loc: (23...24) = "b" │ │ │ │ │ │ ├── content_loc: (5,7)-(5,8) = "b"
│ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ └── unescaped: "b" │ │ │ │ │ │ └── unescaped: "b"
│ │ │ │ │ └── @ EmbeddedStatementsNode (location: (24...28)) │ │ │ │ │ └── @ EmbeddedStatementsNode (location: (5,8)-(5,12))
│ │ │ │ │ ├── opening_loc: (24...26) = "\#{" │ │ │ │ │ ├── opening_loc: (5,8)-(5,10) = "\#{"
│ │ │ │ │ ├── statements: │ │ │ │ │ ├── statements:
│ │ │ │ │ │ @ StatementsNode (location: (26...27)) │ │ │ │ │ │ @ StatementsNode (location: (5,10)-(5,11))
│ │ │ │ │ │ └── body: (length: 1) │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ └── @ CallNode (location: (26...27)) │ │ │ │ │ │ └── @ CallNode (location: (5,10)-(5,11))
│ │ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ │ ├── message_loc: (26...27) = "a" │ │ │ │ │ │ ├── message_loc: (5,10)-(5,11) = "a"
│ │ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ ├── block: ∅ │ │ │ │ │ │ ├── block: ∅
│ │ │ │ │ │ ├── flags: variable_call │ │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ │ └── name: "a" │ │ │ │ │ │ └── name: "a"
│ │ │ │ │ └── closing_loc: (27...28) = "}" │ │ │ │ │ └── closing_loc: (5,11)-(5,12) = "}"
│ │ │ │ └── closing_loc: (28...29) = "\"" │ │ │ │ └── closing_loc: (5,12)-(5,13) = "\""
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (18...19) = "(" │ │ ├── opening_loc: (5,2)-(5,3) = "("
│ │ └── closing_loc: (29...30) = ")" │ │ └── closing_loc: (5,13)-(5,14) = ")"
│ └── body: ∅ │ └── body: ∅
├── @ LambdaNode (location: (36...51)) ├── @ LambdaNode (location: (7,0)-(7,15))
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── operator_loc: (36...38) = "->" │ ├── operator_loc: (7,0)-(7,2) = "->"
│ ├── opening_loc: (49...50) = "{" │ ├── opening_loc: (7,13)-(7,14) = "{"
│ ├── closing_loc: (50...51) = "}" │ ├── closing_loc: (7,14)-(7,15) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (38...48)) │ │ @ BlockParametersNode (location: (7,2)-(7,12))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (39...47)) │ │ │ @ ParametersNode (location: (7,3)-(7,11))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 1) │ │ │ ├── keywords: (length: 1)
│ │ │ │ └── @ KeywordParameterNode (location: (39...47)) │ │ │ │ └── @ KeywordParameterNode (location: (7,3)-(7,11))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ ├── name_loc: (39...41) = "a:" │ │ │ │ ├── name_loc: (7,3)-(7,5) = "a:"
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (42...47)) │ │ │ │ @ CallNode (location: (7,6)-(7,11))
│ │ │ │ ├── receiver: │ │ │ │ ├── receiver:
│ │ │ │ │ @ CallNode (location: (42...43)) │ │ │ │ │ @ CallNode (location: (7,6)-(7,7))
│ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (42...43) = "b" │ │ │ │ │ ├── message_loc: (7,6)-(7,7) = "b"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
@ -106,12 +106,12 @@
│ │ │ │ │ ├── flags: variable_call │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ └── name: "b" │ │ │ │ │ └── name: "b"
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (44...45) = "*" │ │ │ │ ├── message_loc: (7,8)-(7,9) = "*"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: │ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (46...47)) │ │ │ │ │ @ ArgumentsNode (location: (7,10)-(7,11))
│ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (46...47)) │ │ │ │ │ └── @ IntegerNode (location: (7,10)-(7,11))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
@ -120,29 +120,29 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (38...39) = "(" │ │ ├── opening_loc: (7,2)-(7,3) = "("
│ │ └── closing_loc: (47...48) = ")" │ │ └── closing_loc: (7,11)-(7,12) = ")"
│ └── body: ∅ │ └── body: ∅
├── @ LambdaNode (location: (53...72)) ├── @ LambdaNode (location: (9,0)-(9,19))
│ ├── locals: [:foo] │ ├── locals: [:foo]
│ ├── operator_loc: (53...55) = "->" │ ├── operator_loc: (9,0)-(9,2) = "->"
│ ├── opening_loc: (66...68) = "do" │ ├── opening_loc: (9,13)-(9,15) = "do"
│ ├── closing_loc: (69...72) = "end" │ ├── closing_loc: (9,16)-(9,19) = "end"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (56...65)) │ │ @ BlockParametersNode (location: (9,3)-(9,12))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (56...65)) │ │ │ @ ParametersNode (location: (9,3)-(9,12))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (56...65)) │ │ │ │ └── @ OptionalParameterNode (location: (9,3)-(9,12))
│ │ │ │ ├── name: :foo │ │ │ │ ├── name: :foo
│ │ │ │ ├── name_loc: (56...59) = "foo" │ │ │ │ ├── name_loc: (9,3)-(9,6) = "foo"
│ │ │ │ ├── operator_loc: (60...61) = "=" │ │ │ │ ├── operator_loc: (9,7)-(9,8) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (62...65)) │ │ │ │ @ CallNode (location: (9,9)-(9,12))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (62...65) = "bar" │ │ │ │ ├── message_loc: (9,9)-(9,12) = "bar"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -158,28 +158,28 @@
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅ │ │ └── closing_loc: ∅
│ └── body: ∅ │ └── body: ∅
└── @ LambdaNode (location: (74...92)) └── @ LambdaNode (location: (11,0)-(11,18))
├── locals: [:foo] ├── locals: [:foo]
├── operator_loc: (74...76) = "->" ├── operator_loc: (11,0)-(11,2) = "->"
├── opening_loc: (86...88) = "do" ├── opening_loc: (11,12)-(11,14) = "do"
├── closing_loc: (89...92) = "end" ├── closing_loc: (11,15)-(11,18) = "end"
├── parameters: ├── parameters:
│ @ BlockParametersNode (location: (77...85)) │ @ BlockParametersNode (location: (11,3)-(11,11))
│ ├── parameters: │ ├── parameters:
│ │ @ ParametersNode (location: (77...85)) │ │ @ ParametersNode (location: (11,3)-(11,11))
│ │ ├── requireds: (length: 0) │ │ ├── requireds: (length: 0)
│ │ ├── optionals: (length: 0) │ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅ │ │ ├── rest: ∅
│ │ ├── posts: (length: 0) │ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 1) │ │ ├── keywords: (length: 1)
│ │ │ └── @ KeywordParameterNode (location: (77...85)) │ │ │ └── @ KeywordParameterNode (location: (11,3)-(11,11))
│ │ │ ├── name: :foo │ │ │ ├── name: :foo
│ │ │ ├── name_loc: (77...81) = "foo:" │ │ │ ├── name_loc: (11,3)-(11,7) = "foo:"
│ │ │ └── value: │ │ │ └── value:
│ │ │ @ CallNode (location: (82...85)) │ │ │ @ CallNode (location: (11,8)-(11,11))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (82...85) = "bar" │ │ │ ├── message_loc: (11,8)-(11,11) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅

1628
test/yarp/snapshots/method_calls.txt
View file

File diff suppressed because it is too large Load diff

1274
test/yarp/snapshots/methods.txt
View file

File diff suppressed because it is too large Load diff

150
test/yarp/snapshots/modules.txt
View file

@ -1,69 +1,69 @@
@ ProgramNode (location: (0...140)) @ ProgramNode (location: (1,0)-(18,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...140)) @ StatementsNode (location: (1,0)-(18,3))
└── body: (length: 7) └── body: (length: 7)
├── @ ModuleNode (location: (0...18)) ├── @ ModuleNode (location: (1,0)-(1,18))
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── module_keyword_loc: (0...6) = "module" │ ├── module_keyword_loc: (1,0)-(1,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (7...8)) │ │ @ ConstantReadNode (location: (1,7)-(1,8))
│ │ └── name: :A │ │ └── name: :A
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (9...14)) │ │ @ StatementsNode (location: (1,9)-(1,14))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (9...14)) │ │ └── @ LocalVariableWriteNode (location: (1,9)-(1,14))
│ │ ├── name: :a │ │ ├── name: :a
│ │ ├── depth: 0 │ │ ├── depth: 0
│ │ ├── name_loc: (9...10) = "a" │ │ ├── name_loc: (1,9)-(1,10) = "a"
│ │ ├── value: │ │ ├── value:
│ │ │ @ IntegerNode (location: (13...14)) │ │ │ @ IntegerNode (location: (1,13)-(1,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── operator_loc: (11...12) = "=" │ │ └── operator_loc: (1,11)-(1,12) = "="
│ ├── end_keyword_loc: (15...18) = "end" │ ├── end_keyword_loc: (1,15)-(1,18) = "end"
│ └── name: :A │ └── name: :A
├── @ InterpolatedStringNode (location: (20...38)) ├── @ InterpolatedStringNode (location: (3,0)-(3,18))
│ ├── opening_loc: (20...23) = "%Q{" │ ├── opening_loc: (3,0)-(3,3) = "%Q{"
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (23...27)) │ │ ├── @ StringNode (location: (3,3)-(3,7))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (23...27) = "aaa " │ │ │ ├── content_loc: (3,3)-(3,7) = "aaa "
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa " │ │ │ └── unescaped: "aaa "
│ │ ├── @ EmbeddedStatementsNode (location: (27...33)) │ │ ├── @ EmbeddedStatementsNode (location: (3,7)-(3,13))
│ │ │ ├── opening_loc: (27...29) = "\#{" │ │ │ ├── opening_loc: (3,7)-(3,9) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (29...32)) │ │ │ │ @ StatementsNode (location: (3,9)-(3,12))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (29...32)) │ │ │ │ └── @ CallNode (location: (3,9)-(3,12))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (29...32) = "bbb" │ │ │ │ ├── message_loc: (3,9)-(3,12) = "bbb"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bbb" │ │ │ │ └── name: "bbb"
│ │ │ └── closing_loc: (32...33) = "}" │ │ │ └── closing_loc: (3,12)-(3,13) = "}"
│ │ └── @ StringNode (location: (33...37)) │ │ └── @ StringNode (location: (3,13)-(3,17))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (33...37) = " ccc" │ │ ├── content_loc: (3,13)-(3,17) = " ccc"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: " ccc" │ │ └── unescaped: " ccc"
│ └── closing_loc: (37...38) = "}" │ └── closing_loc: (3,17)-(3,18) = "}"
├── @ ModuleNode (location: (40...55)) ├── @ ModuleNode (location: (5,0)-(6,3))
│ ├── locals: [] │ ├── locals: []
│ ├── module_keyword_loc: (40...46) = "module" │ ├── module_keyword_loc: (5,0)-(5,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantPathNode (location: (47...51)) │ │ @ ConstantPathNode (location: (5,7)-(5,11))
│ │ ├── parent: │ │ ├── parent:
│ │ │ @ CallNode (location: (47...48)) │ │ │ @ CallNode (location: (5,7)-(5,8))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (47...48) = "m" │ │ │ ├── message_loc: (5,7)-(5,8) = "m"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -71,35 +71,35 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "m" │ │ │ └── name: "m"
│ │ ├── child: │ │ ├── child:
│ │ │ @ ConstantReadNode (location: (50...51)) │ │ │ @ ConstantReadNode (location: (5,10)-(5,11))
│ │ │ └── name: :M │ │ │ └── name: :M
│ │ └── delimiter_loc: (48...50) = "::" │ │ └── delimiter_loc: (5,8)-(5,10) = "::"
│ ├── body: ∅ │ ├── body: ∅
│ ├── end_keyword_loc: (52...55) = "end" │ ├── end_keyword_loc: (6,0)-(6,3) = "end"
│ └── name: :M │ └── name: :M
├── @ ModuleNode (location: (57...85)) ├── @ ModuleNode (location: (8,0)-(9,19))
│ ├── locals: [:x] │ ├── locals: [:x]
│ ├── module_keyword_loc: (57...63) = "module" │ ├── module_keyword_loc: (8,0)-(8,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (64...65)) │ │ @ ConstantReadNode (location: (8,7)-(8,8))
│ │ └── name: :A │ │ └── name: :A
│ ├── body: │ ├── body:
│ │ @ BeginNode (location: (67...85)) │ │ @ BeginNode (location: (9,1)-(9,19))
│ │ ├── begin_keyword_loc: ∅ │ │ ├── begin_keyword_loc: ∅
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (67...72)) │ │ │ @ StatementsNode (location: (9,1)-(9,6))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableWriteNode (location: (67...72)) │ │ │ └── @ LocalVariableWriteNode (location: (9,1)-(9,6))
│ │ │ ├── name: :x │ │ │ ├── name: :x
│ │ │ ├── depth: 0 │ │ │ ├── depth: 0
│ │ │ ├── name_loc: (67...68) = "x" │ │ │ ├── name_loc: (9,1)-(9,2) = "x"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (71...72)) │ │ │ │ @ IntegerNode (location: (9,5)-(9,6))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (69...70) = "=" │ │ │ └── operator_loc: (9,3)-(9,4) = "="
│ │ ├── rescue_clause: │ │ ├── rescue_clause:
│ │ │ @ RescueNode (location: (74...80)) │ │ │ @ RescueNode (location: (9,8)-(9,14))
│ │ │ ├── keyword_loc: (74...80) = "rescue" │ │ │ ├── keyword_loc: (9,8)-(9,14) = "rescue"
│ │ │ ├── exceptions: (length: 0) │ │ │ ├── exceptions: (length: 0)
│ │ │ ├── operator_loc: ∅ │ │ │ ├── operator_loc: ∅
│ │ │ ├── reference: ∅ │ │ │ ├── reference: ∅
@ -107,73 +107,73 @@
│ │ │ └── consequent: ∅ │ │ │ └── consequent: ∅
│ │ ├── else_clause: ∅ │ │ ├── else_clause: ∅
│ │ ├── ensure_clause: ∅ │ │ ├── ensure_clause: ∅
│ │ └── end_keyword_loc: (82...85) = "end" │ │ └── end_keyword_loc: (9,16)-(9,19) = "end"
│ ├── end_keyword_loc: (82...85) = "end" │ ├── end_keyword_loc: (9,16)-(9,19) = "end"
│ └── name: :A │ └── name: :A
├── @ ModuleNode (location: (87...101)) ├── @ ModuleNode (location: (11,0)-(12,3))
│ ├── locals: [] │ ├── locals: []
│ ├── module_keyword_loc: (87...93) = "module" │ ├── module_keyword_loc: (11,0)-(11,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantPathNode (location: (94...97)) │ │ @ ConstantPathNode (location: (11,7)-(11,10))
│ │ ├── parent: ∅ │ │ ├── parent: ∅
│ │ ├── child: │ │ ├── child:
│ │ │ @ ConstantReadNode (location: (96...97)) │ │ │ @ ConstantReadNode (location: (11,9)-(11,10))
│ │ │ └── name: :A │ │ │ └── name: :A
│ │ └── delimiter_loc: (94...96) = "::" │ │ └── delimiter_loc: (11,7)-(11,9) = "::"
│ ├── body: ∅ │ ├── body: ∅
│ ├── end_keyword_loc: (98...101) = "end" │ ├── end_keyword_loc: (12,0)-(12,3) = "end"
│ └── name: :A │ └── name: :A
├── @ ModuleNode (location: (103...120)) ├── @ ModuleNode (location: (14,0)-(15,3))
│ ├── locals: [] │ ├── locals: []
│ ├── module_keyword_loc: (103...109) = "module" │ ├── module_keyword_loc: (14,0)-(14,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantPathNode (location: (110...116)) │ │ @ ConstantPathNode (location: (14,7)-(14,13))
│ │ ├── parent: │ │ ├── parent:
│ │ │ @ CallNode (location: (110...113)) │ │ │ @ CallNode (location: (14,7)-(14,10))
│ │ │ ├── receiver: │ │ │ ├── receiver:
│ │ │ │ @ ConstantReadNode (location: (110...111)) │ │ │ │ @ ConstantReadNode (location: (14,7)-(14,8))
│ │ │ │ └── name: :A │ │ │ │ └── name: :A
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (111...113) = "[]" │ │ │ ├── message_loc: (14,8)-(14,10) = "[]"
│ │ │ ├── opening_loc: (111...112) = "[" │ │ │ ├── opening_loc: (14,8)-(14,9) = "["
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: (112...113) = "]" │ │ │ ├── closing_loc: (14,9)-(14,10) = "]"
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "[]" │ │ │ └── name: "[]"
│ │ ├── child: │ │ ├── child:
│ │ │ @ ConstantReadNode (location: (115...116)) │ │ │ @ ConstantReadNode (location: (14,12)-(14,13))
│ │ │ └── name: :B │ │ │ └── name: :B
│ │ └── delimiter_loc: (113...115) = "::" │ │ └── delimiter_loc: (14,10)-(14,12) = "::"
│ ├── body: ∅ │ ├── body: ∅
│ ├── end_keyword_loc: (117...120) = "end" │ ├── end_keyword_loc: (15,0)-(15,3) = "end"
│ └── name: :B │ └── name: :B
└── @ ModuleNode (location: (122...140)) └── @ ModuleNode (location: (17,0)-(18,3))
├── locals: [] ├── locals: []
├── module_keyword_loc: (122...128) = "module" ├── module_keyword_loc: (17,0)-(17,6) = "module"
├── constant_path: ├── constant_path:
│ @ ConstantPathNode (location: (129...136)) │ @ ConstantPathNode (location: (17,7)-(17,14))
│ ├── parent: │ ├── parent:
│ │ @ CallNode (location: (129...133)) │ │ @ CallNode (location: (17,7)-(17,11))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ ConstantReadNode (location: (129...130)) │ │ │ @ ConstantReadNode (location: (17,7)-(17,8))
│ │ │ └── name: :A │ │ │ └── name: :A
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (130...133) = "[1]" │ │ ├── message_loc: (17,8)-(17,11) = "[1]"
│ │ ├── opening_loc: (130...131) = "[" │ │ ├── opening_loc: (17,8)-(17,9) = "["
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (131...132)) │ │ │ @ ArgumentsNode (location: (17,9)-(17,10))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (131...132)) │ │ │ └── @ IntegerNode (location: (17,9)-(17,10))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── closing_loc: (132...133) = "]" │ │ ├── closing_loc: (17,10)-(17,11) = "]"
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "[]" │ │ └── name: "[]"
│ ├── child: │ ├── child:
│ │ @ ConstantReadNode (location: (135...136)) │ │ @ ConstantReadNode (location: (17,13)-(17,14))
│ │ └── name: :B │ │ └── name: :B
│ └── delimiter_loc: (133...135) = "::" │ └── delimiter_loc: (17,11)-(17,13) = "::"
├── body: ∅ ├── body: ∅
├── end_keyword_loc: (137...140) = "end" ├── end_keyword_loc: (18,0)-(18,3) = "end"
└── name: :B └── name: :B

140
test/yarp/snapshots/newline_terminated.txt
View file

@ -1,107 +1,107 @@
@ ProgramNode (location: (76...212)) @ ProgramNode (location: (3,0)-(40,0))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (76...212)) @ StatementsNode (location: (3,0)-(40,0))
└── body: (length: 17) └── body: (length: 17)
├── @ StringNode (location: (76...82)) ├── @ StringNode (location: (3,0)-(3,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (76...78) = "% " │ ├── opening_loc: (3,0)-(3,2) = "% "
│ ├── content_loc: (78...81) = "abc" │ ├── content_loc: (3,2)-(3,5) = "abc"
│ ├── closing_loc: (81...82) = " " │ ├── closing_loc: (3,5)-(3,6) = " "
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (84...90)) ├── @ StringNode (location: (4,0)-(4,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (84...86) = "%\t" │ ├── opening_loc: (4,0)-(4,2) = "%\t"
│ ├── content_loc: (86...89) = "abc" │ ├── content_loc: (4,2)-(4,5) = "abc"
│ ├── closing_loc: (89...90) = "\t" │ ├── closing_loc: (4,5)-(4,6) = "\t"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (92...98)) ├── @ StringNode (location: (5,0)-(5,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (92...94) = "%\v" │ ├── opening_loc: (5,0)-(5,2) = "%\v"
│ ├── content_loc: (94...97) = "abc" │ ├── content_loc: (5,2)-(5,5) = "abc"
│ ├── closing_loc: (97...98) = "\v" │ ├── closing_loc: (5,5)-(5,6) = "\v"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (100...106)) ├── @ StringNode (location: (6,0)-(6,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (100...102) = "%\r" │ ├── opening_loc: (6,0)-(6,2) = "%\r"
│ ├── content_loc: (102...105) = "abc" │ ├── content_loc: (6,2)-(6,5) = "abc"
│ ├── closing_loc: (105...106) = "\r" │ ├── closing_loc: (6,5)-(6,6) = "\r"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (108...114)) ├── @ StringNode (location: (7,0)-(8,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (108...110) = "%\n" │ ├── opening_loc: (7,0)-(7,0) = "%\n"
│ ├── content_loc: (110...113) = "abc" │ ├── content_loc: (8,0)-(8,3) = "abc"
│ ├── closing_loc: (113...114) = "\n" │ ├── closing_loc: (8,3)-(8,0) = "\n"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (116...122)) ├── @ StringNode (location: (10,0)-(10,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (116...118) = "%\u0000" │ ├── opening_loc: (10,0)-(10,2) = "%\u0000"
│ ├── content_loc: (118...121) = "abc" │ ├── content_loc: (10,2)-(10,5) = "abc"
│ ├── closing_loc: (121...122) = "\u0000" │ ├── closing_loc: (10,5)-(10,6) = "\u0000"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (124...130)) ├── @ StringNode (location: (11,0)-(12,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (124...126) = "%\n" │ ├── opening_loc: (11,0)-(11,0) = "%\n"
│ ├── content_loc: (126...129) = "abc" │ ├── content_loc: (12,0)-(12,3) = "abc"
│ ├── closing_loc: (129...130) = "\n" │ ├── closing_loc: (12,3)-(12,0) = "\n"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (132...139)) ├── @ StringNode (location: (14,0)-(15,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (132...134) = "%\n" │ ├── opening_loc: (14,0)-(14,0) = "%\n"
│ ├── content_loc: (134...138) = "\rabc" │ ├── content_loc: (15,0)-(15,4) = "\rabc"
│ ├── closing_loc: (138...139) = "\n" │ ├── closing_loc: (15,4)-(15,0) = "\n"
│ └── unescaped: "\rabc" │ └── unescaped: "\rabc"
├── @ StringNode (location: (142...149)) ├── @ StringNode (location: (17,0)-(18,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (142...144) = "%\n" │ ├── opening_loc: (17,0)-(17,0) = "%\n"
│ ├── content_loc: (144...148) = "\rabc" │ ├── content_loc: (18,0)-(18,4) = "\rabc"
│ ├── closing_loc: (148...149) = "\n" │ ├── closing_loc: (18,4)-(18,0) = "\n"
│ └── unescaped: "\rabc" │ └── unescaped: "\rabc"
├── @ StringNode (location: (151...157)) ├── @ StringNode (location: (20,0)-(21,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (151...153) = "%\n" │ ├── opening_loc: (20,0)-(20,0) = "%\n"
│ ├── content_loc: (153...156) = "abc" │ ├── content_loc: (21,0)-(21,3) = "abc"
│ ├── closing_loc: (156...157) = "\n" │ ├── closing_loc: (21,3)-(21,0) = "\n"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (159...165)) ├── @ StringNode (location: (23,0)-(23,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (159...161) = "%\r" │ ├── opening_loc: (23,0)-(23,2) = "%\r"
│ ├── content_loc: (161...164) = "abc" │ ├── content_loc: (23,2)-(23,5) = "abc"
│ ├── closing_loc: (164...165) = "\r" │ ├── closing_loc: (23,5)-(23,6) = "\r"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (167...173)) ├── @ StringNode (location: (24,0)-(25,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (167...169) = "%\n" │ ├── opening_loc: (24,0)-(24,0) = "%\n"
│ ├── content_loc: (169...172) = "abc" │ ├── content_loc: (25,0)-(25,3) = "abc"
│ ├── closing_loc: (172...173) = "\n" │ ├── closing_loc: (25,3)-(25,0) = "\n"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (175...181)) ├── @ StringNode (location: (27,0)-(28,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (175...177) = "%\n" │ ├── opening_loc: (27,0)-(27,0) = "%\n"
│ ├── content_loc: (177...180) = "abc" │ ├── content_loc: (28,0)-(28,3) = "abc"
│ ├── closing_loc: (180...181) = "\n" │ ├── closing_loc: (28,3)-(28,0) = "\n"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ StringNode (location: (182...188)) ├── @ StringNode (location: (30,0)-(31,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (182...184) = "%\n" │ ├── opening_loc: (30,0)-(30,0) = "%\n"
│ ├── content_loc: (184...187) = "foo" │ ├── content_loc: (31,0)-(31,3) = "foo"
│ ├── closing_loc: (187...188) = "\n" │ ├── closing_loc: (31,3)-(31,0) = "\n"
│ └── unescaped: "foo" │ └── unescaped: "foo"
├── @ StringNode (location: (189...196)) ├── @ StringNode (location: (33,0)-(34,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (189...192) = "%q\n" │ ├── opening_loc: (33,0)-(33,0) = "%q\n"
│ ├── content_loc: (192...195) = "foo" │ ├── content_loc: (34,0)-(34,3) = "foo"
│ ├── closing_loc: (195...196) = "\n" │ ├── closing_loc: (34,3)-(34,0) = "\n"
│ └── unescaped: "foo" │ └── unescaped: "foo"
├── @ StringNode (location: (197...204)) ├── @ StringNode (location: (36,0)-(37,0))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (197...200) = "%Q\n" │ ├── opening_loc: (36,0)-(36,0) = "%Q\n"
│ ├── content_loc: (200...203) = "foo" │ ├── content_loc: (37,0)-(37,3) = "foo"
│ ├── closing_loc: (203...204) = "\n" │ ├── closing_loc: (37,3)-(37,0) = "\n"
│ └── unescaped: "foo" │ └── unescaped: "foo"
└── @ RegularExpressionNode (location: (205...212)) └── @ RegularExpressionNode (location: (39,0)-(40,0))
├── opening_loc: (205...208) = "%r\n" ├── opening_loc: (39,0)-(39,0) = "%r\n"
├── content_loc: (208...211) = "foo" ├── content_loc: (40,0)-(40,3) = "foo"
├── closing_loc: (211...212) = "\n" ├── closing_loc: (40,3)-(40,0) = "\n"
├── unescaped: "foo" ├── unescaped: "foo"
└── flags: ∅ └── flags: ∅

146
test/yarp/snapshots/next.txt
View file

@ -1,123 +1,123 @@
@ ProgramNode (location: (0...118)) @ ProgramNode (location: (1,0)-(24,7))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...118)) @ StatementsNode (location: (1,0)-(24,7))
└── body: (length: 11) └── body: (length: 11)
├── @ NextNode (location: (0...4)) ├── @ NextNode (location: (1,0)-(1,4))
│ ├── arguments: ∅ │ ├── arguments: ∅
│ └── keyword_loc: (0...4) = "next" │ └── keyword_loc: (1,0)-(1,4) = "next"
├── @ NextNode (location: (6...24)) ├── @ NextNode (location: (3,0)-(3,18))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (11...24)) │ │ @ ArgumentsNode (location: (3,5)-(3,18))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ ParenthesesNode (location: (11...14)) │ │ ├── @ ParenthesesNode (location: (3,5)-(3,8))
│ │ │ ├── body: │ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (12...13)) │ │ │ │ @ StatementsNode (location: (3,6)-(3,7))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (12...13)) │ │ │ │ └── @ IntegerNode (location: (3,6)-(3,7))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (11...12) = "(" │ │ │ ├── opening_loc: (3,5)-(3,6) = "("
│ │ │ └── closing_loc: (13...14) = ")" │ │ │ └── closing_loc: (3,7)-(3,8) = ")"
│ │ ├── @ ParenthesesNode (location: (16...19)) │ │ ├── @ ParenthesesNode (location: (3,10)-(3,13))
│ │ │ ├── body: │ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (17...18)) │ │ │ │ @ StatementsNode (location: (3,11)-(3,12))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (17...18)) │ │ │ │ └── @ IntegerNode (location: (3,11)-(3,12))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (16...17) = "(" │ │ │ ├── opening_loc: (3,10)-(3,11) = "("
│ │ │ └── closing_loc: (18...19) = ")" │ │ │ └── closing_loc: (3,12)-(3,13) = ")"
│ │ └── @ ParenthesesNode (location: (21...24)) │ │ └── @ ParenthesesNode (location: (3,15)-(3,18))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (22...23)) │ │ │ @ StatementsNode (location: (3,16)-(3,17))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (22...23)) │ │ │ └── @ IntegerNode (location: (3,16)-(3,17))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (21...22) = "(" │ │ ├── opening_loc: (3,15)-(3,16) = "("
│ │ └── closing_loc: (23...24) = ")" │ │ └── closing_loc: (3,17)-(3,18) = ")"
│ └── keyword_loc: (6...10) = "next" │ └── keyword_loc: (3,0)-(3,4) = "next"
├── @ NextNode (location: (26...32)) ├── @ NextNode (location: (5,0)-(5,6))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (31...32)) │ │ @ ArgumentsNode (location: (5,5)-(5,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (31...32)) │ │ └── @ IntegerNode (location: (5,5)-(5,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (26...30) = "next" │ └── keyword_loc: (5,0)-(5,4) = "next"
├── @ NextNode (location: (34...46)) ├── @ NextNode (location: (7,0)-(8,1))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (39...46)) │ │ @ ArgumentsNode (location: (7,5)-(8,1))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (39...40)) │ │ ├── @ IntegerNode (location: (7,5)-(7,6))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (42...43)) │ │ ├── @ IntegerNode (location: (7,8)-(7,9))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (45...46)) │ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (34...38) = "next" │ └── keyword_loc: (7,0)-(7,4) = "next"
├── @ NextNode (location: (48...60)) ├── @ NextNode (location: (10,0)-(10,12))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (53...60)) │ │ @ ArgumentsNode (location: (10,5)-(10,12))
│ │ └── arguments: (length: 3) │ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (53...54)) │ │ ├── @ IntegerNode (location: (10,5)-(10,6))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (56...57)) │ │ ├── @ IntegerNode (location: (10,8)-(10,9))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (59...60)) │ │ └── @ IntegerNode (location: (10,11)-(10,12))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── keyword_loc: (48...52) = "next" │ └── keyword_loc: (10,0)-(10,4) = "next"
├── @ NextNode (location: (62...76)) ├── @ NextNode (location: (12,0)-(12,14))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (67...76)) │ │ @ ArgumentsNode (location: (12,5)-(12,14))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ArrayNode (location: (67...76)) │ │ └── @ ArrayNode (location: (12,5)-(12,14))
│ │ ├── elements: (length: 3) │ │ ├── elements: (length: 3)
│ │ │ ├── @ IntegerNode (location: (68...69)) │ │ │ ├── @ IntegerNode (location: (12,6)-(12,7))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── @ IntegerNode (location: (71...72)) │ │ │ ├── @ IntegerNode (location: (12,9)-(12,10))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (74...75)) │ │ │ └── @ IntegerNode (location: (12,12)-(12,13))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (67...68) = "[" │ │ ├── opening_loc: (12,5)-(12,6) = "["
│ │ └── closing_loc: (75...76) = "]" │ │ └── closing_loc: (12,13)-(12,14) = "]"
│ └── keyword_loc: (62...66) = "next" │ └── keyword_loc: (12,0)-(12,4) = "next"
├── @ NextNode (location: (78...93)) ├── @ NextNode (location: (14,0)-(17,1))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (82...93)) │ │ @ ArgumentsNode (location: (14,4)-(17,1))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (82...93)) │ │ └── @ ParenthesesNode (location: (14,4)-(17,1))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (86...91)) │ │ │ @ StatementsNode (location: (15,2)-(16,3))
│ │ │ └── body: (length: 2) │ │ │ └── body: (length: 2)
│ │ │ ├── @ IntegerNode (location: (86...87)) │ │ │ ├── @ IntegerNode (location: (15,2)-(15,3))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (90...91)) │ │ │ └── @ IntegerNode (location: (16,2)-(16,3))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (82...83) = "(" │ │ ├── opening_loc: (14,4)-(14,5) = "("
│ │ └── closing_loc: (92...93) = ")" │ │ └── closing_loc: (17,0)-(17,1) = ")"
│ └── keyword_loc: (78...82) = "next" │ └── keyword_loc: (14,0)-(14,4) = "next"
├── @ NextNode (location: (95...99)) ├── @ NextNode (location: (19,0)-(19,4))
│ ├── arguments: ∅ │ ├── arguments: ∅
│ └── keyword_loc: (95...99) = "next" │ └── keyword_loc: (19,0)-(19,4) = "next"
├── @ IntegerNode (location: (100...101)) ├── @ IntegerNode (location: (20,0)-(20,1))
│ └── flags: decimal │ └── flags: decimal
├── @ NextNode (location: (103...109)) ├── @ NextNode (location: (22,0)-(22,6))
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (107...109)) │ │ @ ArgumentsNode (location: (22,4)-(22,6))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (107...109)) │ │ └── @ ParenthesesNode (location: (22,4)-(22,6))
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (107...108) = "(" │ │ ├── opening_loc: (22,4)-(22,5) = "("
│ │ └── closing_loc: (108...109) = ")" │ │ └── closing_loc: (22,5)-(22,6) = ")"
│ └── keyword_loc: (103...107) = "next" │ └── keyword_loc: (22,0)-(22,4) = "next"
└── @ NextNode (location: (111...118)) └── @ NextNode (location: (24,0)-(24,7))
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (115...118)) │ @ ArgumentsNode (location: (24,4)-(24,7))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (115...118)) │ └── @ ParenthesesNode (location: (24,4)-(24,7))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (116...117)) │ │ @ StatementsNode (location: (24,5)-(24,6))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (116...117)) │ │ └── @ IntegerNode (location: (24,5)-(24,6))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── opening_loc: (115...116) = "(" │ ├── opening_loc: (24,4)-(24,5) = "("
│ └── closing_loc: (117...118) = ")" │ └── closing_loc: (24,6)-(24,7) = ")"
└── keyword_loc: (111...115) = "next" └── keyword_loc: (24,0)-(24,4) = "next"

42
test/yarp/snapshots/nils.txt
View file

@ -1,32 +1,32 @@
@ ProgramNode (location: (0...40)) @ ProgramNode (location: (1,0)-(12,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...40)) @ StatementsNode (location: (1,0)-(12,11))
└── body: (length: 5) └── body: (length: 5)
├── @ NilNode (location: (0...3)) ├── @ NilNode (location: (1,0)-(1,3))
├── @ ParenthesesNode (location: (5...7)) ├── @ ParenthesesNode (location: (3,0)-(3,2))
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (5...6) = "(" │ ├── opening_loc: (3,0)-(3,1) = "("
│ └── closing_loc: (6...7) = ")" │ └── closing_loc: (3,1)-(3,2) = ")"
├── @ ParenthesesNode (location: (9...16)) ├── @ ParenthesesNode (location: (5,0)-(8,1))
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (9...10) = "(" │ ├── opening_loc: (5,0)-(5,1) = "("
│ └── closing_loc: (15...16) = ")" │ └── closing_loc: (8,0)-(8,1) = ")"
├── @ PostExecutionNode (location: (18...27)) ├── @ PostExecutionNode (location: (10,0)-(10,9))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (24...25)) │ │ @ StatementsNode (location: (10,6)-(10,7))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (24...25)) │ │ └── @ IntegerNode (location: (10,6)-(10,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── keyword_loc: (18...21) = "END" │ ├── keyword_loc: (10,0)-(10,3) = "END"
│ ├── opening_loc: (22...23) = "{" │ ├── opening_loc: (10,4)-(10,5) = "{"
│ └── closing_loc: (26...27) = "}" │ └── closing_loc: (10,8)-(10,9) = "}"
└── @ PreExecutionNode (location: (29...40)) └── @ PreExecutionNode (location: (12,0)-(12,11))
├── statements: ├── statements:
│ @ StatementsNode (location: (37...38)) │ @ StatementsNode (location: (12,8)-(12,9))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ IntegerNode (location: (37...38)) │ └── @ IntegerNode (location: (12,8)-(12,9))
│ └── flags: decimal │ └── flags: decimal
├── keyword_loc: (29...34) = "BEGIN" ├── keyword_loc: (12,0)-(12,5) = "BEGIN"
├── opening_loc: (35...36) = "{" ├── opening_loc: (12,6)-(12,7) = "{"
└── closing_loc: (39...40) = "}" └── closing_loc: (12,10)-(12,11) = "}"

326
test/yarp/snapshots/non_alphanumeric_methods.txt
View file

@ -1,165 +1,165 @@
@ ProgramNode (location: (0...434)) @ ProgramNode (location: (1,0)-(105,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...434)) @ StatementsNode (location: (1,0)-(105,3))
└── body: (length: 36) └── body: (length: 36)
├── @ DefNode (location: (0...9)) ├── @ DefNode (location: (1,0)-(2,3))
│ ├── name: :! │ ├── name: :!
│ ├── name_loc: (4...5) = "!" │ ├── name_loc: (1,4)-(1,5) = "!"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def" │ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (6...9) = "end" │ └── end_keyword_loc: (2,0)-(2,3) = "end"
├── @ DefNode (location: (11...21)) ├── @ DefNode (location: (4,0)-(5,3))
│ ├── name: :!= │ ├── name: :!=
│ ├── name_loc: (15...17) = "!=" │ ├── name_loc: (4,4)-(4,6) = "!="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (11...14) = "def" │ ├── def_keyword_loc: (4,0)-(4,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (18...21) = "end" │ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ DefNode (location: (23...33)) ├── @ DefNode (location: (7,0)-(8,3))
│ ├── name: :!~ │ ├── name: :!~
│ ├── name_loc: (27...29) = "!~" │ ├── name_loc: (7,4)-(7,6) = "!~"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (23...26) = "def" │ ├── def_keyword_loc: (7,0)-(7,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (30...33) = "end" │ └── end_keyword_loc: (8,0)-(8,3) = "end"
├── @ DefNode (location: (35...44)) ├── @ DefNode (location: (10,0)-(11,3))
│ ├── name: :% │ ├── name: :%
│ ├── name_loc: (39...40) = "%" │ ├── name_loc: (10,4)-(10,5) = "%"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (35...38) = "def" │ ├── def_keyword_loc: (10,0)-(10,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (41...44) = "end" │ └── end_keyword_loc: (11,0)-(11,3) = "end"
├── @ DefNode (location: (46...60)) ├── @ DefNode (location: (13,0)-(14,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (55...56) = "+" │ ├── name_loc: (13,9)-(13,10) = "+"
│ ├── receiver: │ ├── receiver:
│ │ @ SelfNode (location: (50...54)) │ │ @ SelfNode (location: (13,4)-(13,8))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (46...49) = "def" │ ├── def_keyword_loc: (13,0)-(13,3) = "def"
│ ├── operator_loc: (54...55) = "." │ ├── operator_loc: (13,8)-(13,9) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (57...60) = "end" │ └── end_keyword_loc: (14,0)-(14,3) = "end"
├── @ DefNode (location: (62...71)) ├── @ DefNode (location: (16,0)-(17,3))
│ ├── name: :& │ ├── name: :&
│ ├── name_loc: (66...67) = "&" │ ├── name_loc: (16,4)-(16,5) = "&"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (62...65) = "def" │ ├── def_keyword_loc: (16,0)-(16,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (68...71) = "end" │ └── end_keyword_loc: (17,0)-(17,3) = "end"
├── @ DefNode (location: (73...82)) ├── @ DefNode (location: (19,0)-(20,3))
│ ├── name: :* │ ├── name: :*
│ ├── name_loc: (77...78) = "*" │ ├── name_loc: (19,4)-(19,5) = "*"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (73...76) = "def" │ ├── def_keyword_loc: (19,0)-(19,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (79...82) = "end" │ └── end_keyword_loc: (20,0)-(20,3) = "end"
├── @ DefNode (location: (84...94)) ├── @ DefNode (location: (22,0)-(23,3))
│ ├── name: :** │ ├── name: :**
│ ├── name_loc: (88...90) = "**" │ ├── name_loc: (22,4)-(22,6) = "**"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (84...87) = "def" │ ├── def_keyword_loc: (22,0)-(22,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (91...94) = "end" │ └── end_keyword_loc: (23,0)-(23,3) = "end"
├── @ StringNode (location: (96...102)) ├── @ StringNode (location: (25,0)-(25,6))
│ ├── flags: ∅ │ ├── flags: ∅
│ ├── opening_loc: (96...98) = "%|" │ ├── opening_loc: (25,0)-(25,2) = "%|"
│ ├── content_loc: (98...101) = "abc" │ ├── content_loc: (25,2)-(25,5) = "abc"
│ ├── closing_loc: (101...102) = "|" │ ├── closing_loc: (25,5)-(25,6) = "|"
│ └── unescaped: "abc" │ └── unescaped: "abc"
├── @ DefNode (location: (104...117)) ├── @ DefNode (location: (27,0)-(28,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (108...109) = "+" │ ├── name_loc: (27,4)-(27,5) = "+"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: │ ├── parameters:
│ │ @ ParametersNode (location: (110...113)) │ │ @ ParametersNode (location: (27,6)-(27,9))
│ │ ├── requireds: (length: 0) │ │ ├── requireds: (length: 0)
│ │ ├── optionals: (length: 0) │ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅ │ │ ├── rest: ∅
│ │ ├── posts: (length: 0) │ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0) │ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest: │ │ ├── keyword_rest:
│ │ │ @ KeywordRestParameterNode (location: (110...113)) │ │ │ @ KeywordRestParameterNode (location: (27,6)-(27,9))
│ │ │ ├── name: :b │ │ │ ├── name: :b
│ │ │ ├── name_loc: (112...113) = "b" │ │ │ ├── name_loc: (27,8)-(27,9) = "b"
│ │ │ └── operator_loc: (110...112) = "**" │ │ │ └── operator_loc: (27,6)-(27,8) = "**"
│ │ └── block: ∅ │ │ └── block: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── def_keyword_loc: (104...107) = "def" │ ├── def_keyword_loc: (27,0)-(27,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (114...117) = "end" │ └── end_keyword_loc: (28,0)-(28,3) = "end"
├── @ DefNode (location: (119...130)) ├── @ DefNode (location: (30,0)-(31,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (123...124) = "+" │ ├── name_loc: (30,4)-(30,5) = "+"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (119...122) = "def" │ ├── def_keyword_loc: (30,0)-(30,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: (124...125) = "(" │ ├── lparen_loc: (30,5)-(30,6) = "("
│ ├── rparen_loc: (125...126) = ")" │ ├── rparen_loc: (30,6)-(30,7) = ")"
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (127...130) = "end" │ └── end_keyword_loc: (31,0)-(31,3) = "end"
├── @ DefNode (location: (132...143)) ├── @ DefNode (location: (33,0)-(34,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (136...137) = "+" │ ├── name_loc: (33,4)-(33,5) = "+"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: │ ├── parameters:
│ │ @ ParametersNode (location: (138...139)) │ │ @ ParametersNode (location: (33,6)-(33,7))
│ │ ├── requireds: (length: 1) │ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredParameterNode (location: (138...139)) │ │ │ └── @ RequiredParameterNode (location: (33,6)-(33,7))
│ │ │ └── name: :b │ │ │ └── name: :b
│ │ ├── optionals: (length: 0) │ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅ │ │ ├── rest: ∅
@ -169,73 +169,73 @@
│ │ └── block: ∅ │ │ └── block: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── def_keyword_loc: (132...135) = "def" │ ├── def_keyword_loc: (33,0)-(33,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (140...143) = "end" │ └── end_keyword_loc: (34,0)-(34,3) = "end"
├── @ DefNode (location: (145...159)) ├── @ DefNode (location: (36,0)-(37,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (154...155) = "+" │ ├── name_loc: (36,9)-(36,10) = "+"
│ ├── receiver: │ ├── receiver:
│ │ @ SelfNode (location: (149...153)) │ │ @ SelfNode (location: (36,4)-(36,8))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (145...148) = "def" │ ├── def_keyword_loc: (36,0)-(36,3) = "def"
│ ├── operator_loc: (153...154) = "." │ ├── operator_loc: (36,8)-(36,9) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (156...159) = "end" │ └── end_keyword_loc: (37,0)-(37,3) = "end"
├── @ DefNode (location: (161...170)) ├── @ DefNode (location: (39,0)-(40,3))
│ ├── name: :+ │ ├── name: :+
│ ├── name_loc: (165...166) = "+" │ ├── name_loc: (39,4)-(39,5) = "+"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (161...164) = "def" │ ├── def_keyword_loc: (39,0)-(39,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (167...170) = "end" │ └── end_keyword_loc: (40,0)-(40,3) = "end"
├── @ DefNode (location: (172...182)) ├── @ DefNode (location: (42,0)-(43,3))
│ ├── name: :+@ │ ├── name: :+@
│ ├── name_loc: (176...178) = "+@" │ ├── name_loc: (42,4)-(42,6) = "+@"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (172...175) = "def" │ ├── def_keyword_loc: (42,0)-(42,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (179...182) = "end" │ └── end_keyword_loc: (43,0)-(43,3) = "end"
├── @ DefNode (location: (184...193)) ├── @ DefNode (location: (45,0)-(46,3))
│ ├── name: :- │ ├── name: :-
│ ├── name_loc: (188...189) = "-" │ ├── name_loc: (45,4)-(45,5) = "-"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (184...187) = "def" │ ├── def_keyword_loc: (45,0)-(45,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (190...193) = "end" │ └── end_keyword_loc: (46,0)-(46,3) = "end"
├── @ DefNode (location: (195...206)) ├── @ DefNode (location: (48,0)-(48,11))
│ ├── name: :- │ ├── name: :-
│ ├── name_loc: (201...202) = "-" │ ├── name_loc: (48,6)-(48,7) = "-"
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (199...200)) │ │ @ CallNode (location: (48,4)-(48,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (199...200) = "a" │ │ ├── message_loc: (48,4)-(48,5) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -245,257 +245,257 @@
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (195...198) = "def" │ ├── def_keyword_loc: (48,0)-(48,3) = "def"
│ ├── operator_loc: (200...201) = "." │ ├── operator_loc: (48,5)-(48,6) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (203...206) = "end" │ └── end_keyword_loc: (48,8)-(48,11) = "end"
├── @ DefNode (location: (208...218)) ├── @ DefNode (location: (50,0)-(51,3))
│ ├── name: :-@ │ ├── name: :-@
│ ├── name_loc: (212...214) = "-@" │ ├── name_loc: (50,4)-(50,6) = "-@"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (208...211) = "def" │ ├── def_keyword_loc: (50,0)-(50,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (215...218) = "end" │ └── end_keyword_loc: (51,0)-(51,3) = "end"
├── @ DefNode (location: (220...229)) ├── @ DefNode (location: (53,0)-(54,3))
│ ├── name: :/ │ ├── name: :/
│ ├── name_loc: (224...225) = "/" │ ├── name_loc: (53,4)-(53,5) = "/"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (220...223) = "def" │ ├── def_keyword_loc: (53,0)-(53,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (226...229) = "end" │ └── end_keyword_loc: (54,0)-(54,3) = "end"
├── @ DefNode (location: (231...240)) ├── @ DefNode (location: (56,0)-(57,3))
│ ├── name: :< │ ├── name: :<
│ ├── name_loc: (235...236) = "<" │ ├── name_loc: (56,4)-(56,5) = "<"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (231...234) = "def" │ ├── def_keyword_loc: (56,0)-(56,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (237...240) = "end" │ └── end_keyword_loc: (57,0)-(57,3) = "end"
├── @ DefNode (location: (242...252)) ├── @ DefNode (location: (59,0)-(60,3))
│ ├── name: :<< │ ├── name: :<<
│ ├── name_loc: (246...248) = "<<" │ ├── name_loc: (59,4)-(59,6) = "<<"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (242...245) = "def" │ ├── def_keyword_loc: (59,0)-(59,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (249...252) = "end" │ └── end_keyword_loc: (60,0)-(60,3) = "end"
├── @ DefNode (location: (254...264)) ├── @ DefNode (location: (62,0)-(63,3))
│ ├── name: :<= │ ├── name: :<=
│ ├── name_loc: (258...260) = "<=" │ ├── name_loc: (62,4)-(62,6) = "<="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (254...257) = "def" │ ├── def_keyword_loc: (62,0)-(62,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (261...264) = "end" │ └── end_keyword_loc: (63,0)-(63,3) = "end"
├── @ DefNode (location: (266...277)) ├── @ DefNode (location: (65,0)-(66,3))
│ ├── name: :<=> │ ├── name: :<=>
│ ├── name_loc: (270...273) = "<=>" │ ├── name_loc: (65,4)-(65,7) = "<=>"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (266...269) = "def" │ ├── def_keyword_loc: (65,0)-(65,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (274...277) = "end" │ └── end_keyword_loc: (66,0)-(66,3) = "end"
├── @ DefNode (location: (279...289)) ├── @ DefNode (location: (68,0)-(69,3))
│ ├── name: :== │ ├── name: :==
│ ├── name_loc: (283...285) = "==" │ ├── name_loc: (68,4)-(68,6) = "=="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (279...282) = "def" │ ├── def_keyword_loc: (68,0)-(68,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (286...289) = "end" │ └── end_keyword_loc: (69,0)-(69,3) = "end"
├── @ DefNode (location: (291...302)) ├── @ DefNode (location: (71,0)-(72,3))
│ ├── name: :=== │ ├── name: :===
│ ├── name_loc: (295...298) = "===" │ ├── name_loc: (71,4)-(71,7) = "==="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (291...294) = "def" │ ├── def_keyword_loc: (71,0)-(71,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (299...302) = "end" │ └── end_keyword_loc: (72,0)-(72,3) = "end"
├── @ DefNode (location: (304...314)) ├── @ DefNode (location: (74,0)-(75,3))
│ ├── name: :=~ │ ├── name: :=~
│ ├── name_loc: (308...310) = "=~" │ ├── name_loc: (74,4)-(74,6) = "=~"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (304...307) = "def" │ ├── def_keyword_loc: (74,0)-(74,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (311...314) = "end" │ └── end_keyword_loc: (75,0)-(75,3) = "end"
├── @ DefNode (location: (316...325)) ├── @ DefNode (location: (77,0)-(78,3))
│ ├── name: :> │ ├── name: :>
│ ├── name_loc: (320...321) = ">" │ ├── name_loc: (77,4)-(77,5) = ">"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (316...319) = "def" │ ├── def_keyword_loc: (77,0)-(77,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (322...325) = "end" │ └── end_keyword_loc: (78,0)-(78,3) = "end"
├── @ DefNode (location: (327...337)) ├── @ DefNode (location: (80,0)-(81,3))
│ ├── name: :>= │ ├── name: :>=
│ ├── name_loc: (331...333) = ">=" │ ├── name_loc: (80,4)-(80,6) = ">="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (327...330) = "def" │ ├── def_keyword_loc: (80,0)-(80,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (334...337) = "end" │ └── end_keyword_loc: (81,0)-(81,3) = "end"
├── @ DefNode (location: (339...349)) ├── @ DefNode (location: (83,0)-(84,3))
│ ├── name: :>> │ ├── name: :>>
│ ├── name_loc: (343...345) = ">>" │ ├── name_loc: (83,4)-(83,6) = ">>"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (339...342) = "def" │ ├── def_keyword_loc: (83,0)-(83,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (346...349) = "end" │ └── end_keyword_loc: (84,0)-(84,3) = "end"
├── @ DefNode (location: (351...361)) ├── @ DefNode (location: (86,0)-(87,3))
│ ├── name: :[] │ ├── name: :[]
│ ├── name_loc: (355...357) = "[]" │ ├── name_loc: (86,4)-(86,6) = "[]"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (351...354) = "def" │ ├── def_keyword_loc: (86,0)-(86,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (358...361) = "end" │ └── end_keyword_loc: (87,0)-(87,3) = "end"
├── @ DefNode (location: (363...374)) ├── @ DefNode (location: (89,0)-(90,3))
│ ├── name: :[]= │ ├── name: :[]=
│ ├── name_loc: (367...370) = "[]=" │ ├── name_loc: (89,4)-(89,7) = "[]="
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (363...366) = "def" │ ├── def_keyword_loc: (89,0)-(89,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (371...374) = "end" │ └── end_keyword_loc: (90,0)-(90,3) = "end"
├── @ DefNode (location: (376...385)) ├── @ DefNode (location: (92,0)-(93,3))
│ ├── name: :^ │ ├── name: :^
│ ├── name_loc: (380...381) = "^" │ ├── name_loc: (92,4)-(92,5) = "^"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (376...379) = "def" │ ├── def_keyword_loc: (92,0)-(92,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (382...385) = "end" │ └── end_keyword_loc: (93,0)-(93,3) = "end"
├── @ DefNode (location: (387...396)) ├── @ DefNode (location: (95,0)-(96,3))
│ ├── name: :` │ ├── name: :`
│ ├── name_loc: (391...392) = "`" │ ├── name_loc: (95,4)-(95,5) = "`"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (387...390) = "def" │ ├── def_keyword_loc: (95,0)-(95,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (393...396) = "end" │ └── end_keyword_loc: (96,0)-(96,3) = "end"
├── @ DefNode (location: (398...412)) ├── @ DefNode (location: (98,0)-(99,3))
│ ├── name: :` │ ├── name: :`
│ ├── name_loc: (407...408) = "`" │ ├── name_loc: (98,9)-(98,10) = "`"
│ ├── receiver: │ ├── receiver:
│ │ @ SelfNode (location: (402...406)) │ │ @ SelfNode (location: (98,4)-(98,8))
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (398...401) = "def" │ ├── def_keyword_loc: (98,0)-(98,3) = "def"
│ ├── operator_loc: (406...407) = "." │ ├── operator_loc: (98,8)-(98,9) = "."
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (409...412) = "end" │ └── end_keyword_loc: (99,0)-(99,3) = "end"
├── @ DefNode (location: (414...423)) ├── @ DefNode (location: (101,0)-(102,3))
│ ├── name: :| │ ├── name: :|
│ ├── name_loc: (418...419) = "|" │ ├── name_loc: (101,4)-(101,5) = "|"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (414...417) = "def" │ ├── def_keyword_loc: (101,0)-(101,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: ∅ │ ├── equal_loc: ∅
│ └── end_keyword_loc: (420...423) = "end" │ └── end_keyword_loc: (102,0)-(102,3) = "end"
└── @ DefNode (location: (425...434)) └── @ DefNode (location: (104,0)-(105,3))
├── name: :~ ├── name: :~
├── name_loc: (429...430) = "~" ├── name_loc: (104,4)-(104,5) = "~"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ∅ ├── parameters: ∅
├── body: ∅ ├── body: ∅
├── locals: [] ├── locals: []
├── def_keyword_loc: (425...428) = "def" ├── def_keyword_loc: (104,0)-(104,3) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── rparen_loc: ∅ ├── rparen_loc: ∅
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (431...434) = "end" └── end_keyword_loc: (105,0)-(105,3) = "end"

176
test/yarp/snapshots/not.txt
View file

@ -1,16 +1,16 @@
@ ProgramNode (location: (0...190)) @ ProgramNode (location: (1,0)-(37,16))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...190)) @ StatementsNode (location: (1,0)-(37,16))
└── body: (length: 10) └── body: (length: 10)
├── @ AndNode (location: (0...19)) ├── @ AndNode (location: (1,0)-(1,19))
│ ├── left: │ ├── left:
│ │ @ CallNode (location: (0...7)) │ │ @ CallNode (location: (1,0)-(1,7))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (4...7)) │ │ │ @ CallNode (location: (1,4)-(1,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (4...7) = "foo" │ │ │ ├── message_loc: (1,4)-(1,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -18,7 +18,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "not" │ │ ├── message_loc: (1,0)-(1,3) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -26,12 +26,12 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (12...19)) │ │ @ CallNode (location: (1,12)-(1,19))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (16...19)) │ │ │ @ CallNode (location: (1,16)-(1,19))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (16...19) = "bar" │ │ │ ├── message_loc: (1,16)-(1,19) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -39,22 +39,22 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (12...15) = "not" │ │ ├── message_loc: (1,12)-(1,15) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ └── operator_loc: (8...11) = "and" │ └── operator_loc: (1,8)-(1,11) = "and"
├── @ CallNode (location: (21...37)) ├── @ CallNode (location: (3,0)-(3,16))
│ ├── receiver: │ ├── receiver:
│ │ @ AndNode (location: (25...36)) │ │ @ AndNode (location: (3,4)-(3,15))
│ │ ├── left: │ │ ├── left:
│ │ │ @ CallNode (location: (25...28)) │ │ │ @ CallNode (location: (3,4)-(3,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (25...28) = "foo" │ │ │ ├── message_loc: (3,4)-(3,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -62,31 +62,31 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── right: │ │ ├── right:
│ │ │ @ CallNode (location: (33...36)) │ │ │ @ CallNode (location: (3,12)-(3,15))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (33...36) = "bar" │ │ │ ├── message_loc: (3,12)-(3,15) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ └── operator_loc: (29...32) = "and" │ │ └── operator_loc: (3,8)-(3,11) = "and"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (21...24) = "not" │ ├── message_loc: (3,0)-(3,3) = "not"
│ ├── opening_loc: (24...25) = "(" │ ├── opening_loc: (3,3)-(3,4) = "("
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: (36...37) = ")" │ ├── closing_loc: (3,15)-(3,16) = ")"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
├── @ CallNode (location: (39...46)) ├── @ CallNode (location: (5,0)-(5,7))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (43...46)) │ │ @ CallNode (location: (5,4)-(5,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (43...46) = "foo" │ │ ├── message_loc: (5,4)-(5,7) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -94,21 +94,21 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (39...42) = "not" │ ├── message_loc: (5,0)-(5,3) = "not"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
├── @ AndNode (location: (48...69)) ├── @ AndNode (location: (7,0)-(8,5))
│ ├── left: │ ├── left:
│ │ @ CallNode (location: (48...55)) │ │ @ CallNode (location: (7,0)-(7,7))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (52...55)) │ │ │ @ CallNode (location: (7,4)-(7,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (52...55) = "foo" │ │ │ ├── message_loc: (7,4)-(7,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -116,7 +116,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (48...51) = "not" │ │ ├── message_loc: (7,0)-(7,3) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -124,12 +124,12 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (60...69)) │ │ @ CallNode (location: (7,12)-(8,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (66...69)) │ │ │ @ CallNode (location: (8,2)-(8,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (66...69) = "bar" │ │ │ ├── message_loc: (8,2)-(8,5) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -137,22 +137,22 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (60...63) = "not" │ │ ├── message_loc: (7,12)-(7,15) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ └── operator_loc: (56...59) = "and" │ └── operator_loc: (7,8)-(7,11) = "and"
├── @ AndNode (location: (72...97)) ├── @ AndNode (location: (11,0)-(13,5))
│ ├── left: │ ├── left:
│ │ @ CallNode (location: (72...79)) │ │ @ CallNode (location: (11,0)-(11,7))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (76...79)) │ │ │ @ CallNode (location: (11,4)-(11,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (76...79) = "foo" │ │ │ ├── message_loc: (11,4)-(11,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -160,7 +160,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (72...75) = "not" │ │ ├── message_loc: (11,0)-(11,3) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -168,12 +168,12 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (88...97)) │ │ @ CallNode (location: (12,4)-(13,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (94...97)) │ │ │ @ CallNode (location: (13,2)-(13,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (94...97) = "bar" │ │ │ ├── message_loc: (13,2)-(13,5) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -181,22 +181,22 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (88...91) = "not" │ │ ├── message_loc: (12,4)-(12,7) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ └── operator_loc: (80...83) = "and" │ └── operator_loc: (11,8)-(11,11) = "and"
├── @ AndNode (location: (100...125)) ├── @ AndNode (location: (16,0)-(20,5))
│ ├── left: │ ├── left:
│ │ @ CallNode (location: (100...107)) │ │ @ CallNode (location: (16,0)-(16,7))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (104...107)) │ │ │ @ CallNode (location: (16,4)-(16,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (104...107) = "foo" │ │ │ ├── message_loc: (16,4)-(16,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -204,7 +204,7 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (100...103) = "not" │ │ ├── message_loc: (16,0)-(16,3) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -212,12 +212,12 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (114...125)) │ │ @ CallNode (location: (17,2)-(20,5))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ CallNode (location: (122...125)) │ │ │ @ CallNode (location: (20,2)-(20,5))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (122...125) = "bar" │ │ │ ├── message_loc: (20,2)-(20,5) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -225,20 +225,20 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (114...117) = "not" │ │ ├── message_loc: (17,2)-(17,5) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ └── operator_loc: (108...111) = "and" │ └── operator_loc: (16,8)-(16,11) = "and"
├── @ CallNode (location: (127...138)) ├── @ CallNode (location: (22,0)-(25,1))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (131...134)) │ │ @ CallNode (location: (22,4)-(22,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (131...134) = "foo" │ │ ├── message_loc: (22,4)-(22,7) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -246,19 +246,19 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (127...130) = "not" │ ├── message_loc: (22,0)-(22,3) = "not"
│ ├── opening_loc: (130...131) = "(" │ ├── opening_loc: (22,3)-(22,4) = "("
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: (137...138) = ")" │ ├── closing_loc: (25,0)-(25,1) = ")"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
├── @ CallNode (location: (140...156)) ├── @ CallNode (location: (27,0)-(33,3))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (147...150)) │ │ @ CallNode (location: (30,0)-(30,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (147...150) = "foo" │ │ ├── message_loc: (30,0)-(30,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -266,21 +266,21 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (140...143) = "not" │ ├── message_loc: (27,0)-(27,3) = "not"
│ ├── opening_loc: (143...144) = "(" │ ├── opening_loc: (27,3)-(27,4) = "("
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: (155...156) = ")" │ ├── closing_loc: (33,2)-(33,3) = ")"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
├── @ CallNode (location: (158...172)) ├── @ CallNode (location: (35,0)-(35,14))
│ ├── receiver: │ ├── receiver:
│ │ @ FlipFlopNode (location: (162...172)) │ │ @ FlipFlopNode (location: (35,4)-(35,14))
│ │ ├── left: │ │ ├── left:
│ │ │ @ CallNode (location: (162...165)) │ │ │ @ CallNode (location: (35,4)-(35,7))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (162...165) = "foo" │ │ │ ├── message_loc: (35,4)-(35,7) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -288,38 +288,38 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── right: │ │ ├── right:
│ │ │ @ CallNode (location: (169...172)) │ │ │ @ CallNode (location: (35,11)-(35,14))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (169...172) = "bar" │ │ │ ├── message_loc: (35,11)-(35,14) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── operator_loc: (166...168) = ".." │ │ ├── operator_loc: (35,8)-(35,10) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (158...161) = "not" │ ├── message_loc: (35,0)-(35,3) = "not"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "!" │ └── name: "!"
└── @ CallNode (location: (174...190)) └── @ CallNode (location: (37,0)-(37,16))
├── receiver: ├── receiver:
│ @ ParenthesesNode (location: (178...190)) │ @ ParenthesesNode (location: (37,4)-(37,16))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (179...189)) │ │ @ StatementsNode (location: (37,5)-(37,15))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ FlipFlopNode (location: (179...189)) │ │ └── @ FlipFlopNode (location: (37,5)-(37,15))
│ │ ├── left: │ │ ├── left:
│ │ │ @ CallNode (location: (179...182)) │ │ │ @ CallNode (location: (37,5)-(37,8))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (179...182) = "foo" │ │ │ ├── message_loc: (37,5)-(37,8) = "foo"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -327,22 +327,22 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "foo" │ │ │ └── name: "foo"
│ │ ├── right: │ │ ├── right:
│ │ │ @ CallNode (location: (186...189)) │ │ │ @ CallNode (location: (37,12)-(37,15))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (186...189) = "bar" │ │ │ ├── message_loc: (37,12)-(37,15) = "bar"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "bar" │ │ │ └── name: "bar"
│ │ ├── operator_loc: (183...185) = ".." │ │ ├── operator_loc: (37,9)-(37,11) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── opening_loc: (178...179) = "(" │ ├── opening_loc: (37,4)-(37,5) = "("
│ └── closing_loc: (189...190) = ")" │ └── closing_loc: (37,15)-(37,16) = ")"
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (174...177) = "not" ├── message_loc: (37,0)-(37,3) = "not"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

104
test/yarp/snapshots/numbers.txt
View file

@ -1,102 +1,102 @@
@ ProgramNode (location: (0...161)) @ ProgramNode (location: (1,0)-(63,5))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...161)) @ StatementsNode (location: (1,0)-(63,5))
└── body: (length: 32) └── body: (length: 32)
├── @ IntegerNode (location: (0...1)) ├── @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (3...4)) ├── @ IntegerNode (location: (3,0)-(3,1))
│ └── flags: decimal │ └── flags: decimal
├── @ FloatNode (location: (6...9)) ├── @ FloatNode (location: (5,0)-(5,3))
├── @ IntegerNode (location: (11...12)) ├── @ IntegerNode (location: (7,0)-(7,1))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (14...17)) ├── @ IntegerNode (location: (9,0)-(9,3))
│ └── flags: binary │ └── flags: binary
├── @ IntegerNode (location: (19...22)) ├── @ IntegerNode (location: (11,0)-(11,3))
│ └── flags: binary │ └── flags: binary
├── @ IntegerNode (location: (24...28)) ├── @ IntegerNode (location: (13,0)-(13,4))
│ └── flags: binary │ └── flags: binary
├── @ IntegerNode (location: (30...33)) ├── @ IntegerNode (location: (15,0)-(15,3))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (35...38)) ├── @ IntegerNode (location: (17,0)-(17,3))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (40...43)) ├── @ IntegerNode (location: (19,0)-(19,3))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (45...47)) ├── @ IntegerNode (location: (21,0)-(21,2))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (49...51)) ├── @ IntegerNode (location: (23,0)-(23,2))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (53...55)) ├── @ IntegerNode (location: (25,0)-(25,2))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (57...60)) ├── @ IntegerNode (location: (27,0)-(27,3))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (62...65)) ├── @ IntegerNode (location: (29,0)-(29,3))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (67...70)) ├── @ IntegerNode (location: (31,0)-(31,3))
│ └── flags: octal │ └── flags: octal
├── @ IntegerNode (location: (72...75)) ├── @ IntegerNode (location: (33,0)-(33,3))
│ └── flags: hexadecimal │ └── flags: hexadecimal
├── @ IntegerNode (location: (77...80)) ├── @ IntegerNode (location: (35,0)-(35,3))
│ └── flags: hexadecimal │ └── flags: hexadecimal
├── @ IntegerNode (location: (82...85)) ├── @ IntegerNode (location: (37,0)-(37,3))
│ └── flags: hexadecimal │ └── flags: hexadecimal
├── @ ImaginaryNode (location: (87...89)) ├── @ ImaginaryNode (location: (39,0)-(39,2))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (87...88)) │ @ IntegerNode (location: (39,0)-(39,1))
│ └── flags: decimal │ └── flags: decimal
├── @ RationalNode (location: (91...93)) ├── @ RationalNode (location: (41,0)-(41,2))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (91...92)) │ @ IntegerNode (location: (41,0)-(41,1))
│ └── flags: decimal │ └── flags: decimal
├── @ IntegerNode (location: (95...97)) ├── @ IntegerNode (location: (43,0)-(43,2))
│ └── flags: decimal │ └── flags: decimal
├── @ ImaginaryNode (location: (99...102)) ├── @ ImaginaryNode (location: (45,0)-(45,3))
│ └── numeric: │ └── numeric:
│ @ RationalNode (location: (99...101)) │ @ RationalNode (location: (45,0)-(45,2))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (99...100)) │ @ IntegerNode (location: (45,0)-(45,1))
│ └── flags: decimal │ └── flags: decimal
├── @ ImaginaryNode (location: (104...109)) ├── @ ImaginaryNode (location: (47,0)-(47,5))
│ └── numeric: │ └── numeric:
│ @ RationalNode (location: (104...108)) │ @ RationalNode (location: (47,0)-(47,4))
│ └── numeric: │ └── numeric:
│ @ FloatNode (location: (104...107)) │ @ FloatNode (location: (47,0)-(47,3))
├── @ ImaginaryNode (location: (111...115)) ├── @ ImaginaryNode (location: (49,0)-(49,4))
│ └── numeric: │ └── numeric:
│ @ RationalNode (location: (111...114)) │ @ RationalNode (location: (49,0)-(49,3))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (111...113)) │ @ IntegerNode (location: (49,0)-(49,2))
│ └── flags: decimal │ └── flags: decimal
├── @ ImaginaryNode (location: (117...123)) ├── @ ImaginaryNode (location: (51,0)-(51,6))
│ └── numeric: │ └── numeric:
│ @ RationalNode (location: (117...122)) │ @ RationalNode (location: (51,0)-(51,5))
│ └── numeric: │ └── numeric:
│ @ FloatNode (location: (117...121)) │ @ FloatNode (location: (51,0)-(51,4))
├── @ RationalNode (location: (125...129)) ├── @ RationalNode (location: (53,0)-(53,4))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (125...128)) │ @ IntegerNode (location: (53,0)-(53,3))
│ └── flags: octal │ └── flags: octal
├── @ ImaginaryNode (location: (131...135)) ├── @ ImaginaryNode (location: (55,0)-(55,4))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (131...134)) │ @ IntegerNode (location: (55,0)-(55,3))
│ └── flags: octal │ └── flags: octal
├── @ ImaginaryNode (location: (137...142)) ├── @ ImaginaryNode (location: (57,0)-(57,5))
│ └── numeric: │ └── numeric:
│ @ RationalNode (location: (137...141)) │ @ RationalNode (location: (57,0)-(57,4))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (137...140)) │ @ IntegerNode (location: (57,0)-(57,3))
│ └── flags: octal │ └── flags: octal
├── @ RationalNode (location: (144...148)) ├── @ RationalNode (location: (59,0)-(59,4))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (144...147)) │ @ IntegerNode (location: (59,0)-(59,3))
│ └── flags: decimal │ └── flags: decimal
├── @ ImaginaryNode (location: (150...154)) ├── @ ImaginaryNode (location: (61,0)-(61,4))
│ └── numeric: │ └── numeric:
│ @ IntegerNode (location: (150...153)) │ @ IntegerNode (location: (61,0)-(61,3))
│ └── flags: decimal │ └── flags: decimal
└── @ ImaginaryNode (location: (156...161)) └── @ ImaginaryNode (location: (63,0)-(63,5))
└── numeric: └── numeric:
@ RationalNode (location: (156...160)) @ RationalNode (location: (63,0)-(63,4))
└── numeric: └── numeric:
@ IntegerNode (location: (156...159)) @ IntegerNode (location: (63,0)-(63,3))
└── flags: binary └── flags: binary

3536
test/yarp/snapshots/patterns.txt
View file

File diff suppressed because it is too large Load diff

336
test/yarp/snapshots/procs.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...266)) @ ProgramNode (location: (1,0)-(27,19))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...266)) @ StatementsNode (location: (1,0)-(27,19))
└── body: (length: 10) └── body: (length: 10)
├── @ LambdaNode (location: (0...21)) ├── @ LambdaNode (location: (1,0)-(1,21))
│ ├── locals: [:a, :b, :c, :d] │ ├── locals: [:a, :b, :c, :d]
│ ├── operator_loc: (0...2) = "->" │ ├── operator_loc: (1,0)-(1,2) = "->"
│ ├── opening_loc: (16...17) = "{" │ ├── opening_loc: (1,16)-(1,17) = "{"
│ ├── closing_loc: (20...21) = "}" │ ├── closing_loc: (1,20)-(1,21) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (3...15)) │ │ @ BlockParametersNode (location: (1,3)-(1,15))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (4...5)) │ │ │ @ ParametersNode (location: (1,4)-(1,5))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (4...5)) │ │ │ │ └── @ RequiredParameterNode (location: (1,4)-(1,5))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -22,270 +22,270 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 3) │ │ ├── locals: (length: 3)
│ │ │ ├── @ BlockLocalVariableNode (location: (7...8)) │ │ │ ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── @ BlockLocalVariableNode (location: (10...11)) │ │ │ ├── @ BlockLocalVariableNode (location: (1,10)-(1,11))
│ │ │ │ └── name: :c │ │ │ │ └── name: :c
│ │ │ └── @ BlockLocalVariableNode (location: (13...14)) │ │ │ └── @ BlockLocalVariableNode (location: (1,13)-(1,14))
│ │ │ └── name: :d │ │ │ └── name: :d
│ │ ├── opening_loc: (3...4) = "(" │ │ ├── opening_loc: (1,3)-(1,4) = "("
│ │ └── closing_loc: (14...15) = ")" │ │ └── closing_loc: (1,14)-(1,15) = ")"
│ └── body: │ └── body:
│ @ StatementsNode (location: (18...19)) │ @ StatementsNode (location: (1,18)-(1,19))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (18...19)) │ └── @ LocalVariableReadNode (location: (1,18)-(1,19))
│ ├── name: :b │ ├── name: :b
│ └── depth: 0 │ └── depth: 0
├── @ LambdaNode (location: (23...39)) ├── @ LambdaNode (location: (3,0)-(5,3))
│ ├── locals: [] │ ├── locals: []
│ ├── operator_loc: (23...25) = "->" │ ├── operator_loc: (3,0)-(3,2) = "->"
│ ├── opening_loc: (26...28) = "do" │ ├── opening_loc: (3,3)-(3,5) = "do"
│ ├── closing_loc: (36...39) = "end" │ ├── closing_loc: (5,0)-(5,3) = "end"
│ ├── parameters: ∅ │ ├── parameters: ∅
│ └── body: │ └── body:
│ @ BeginNode (location: (29...39)) │ @ BeginNode (location: (4,0)-(5,3))
│ ├── begin_keyword_loc: ∅ │ ├── begin_keyword_loc: ∅
│ ├── statements: ∅ │ ├── statements: ∅
│ ├── rescue_clause: ∅ │ ├── rescue_clause: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (29...39)) │ │ @ EnsureNode (location: (4,0)-(5,3))
│ │ ├── ensure_keyword_loc: (29...35) = "ensure" │ │ ├── ensure_keyword_loc: (4,0)-(4,6) = "ensure"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (36...39) = "end" │ │ └── end_keyword_loc: (5,0)-(5,3) = "end"
│ └── end_keyword_loc: (36...39) = "end" │ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ LambdaNode (location: (41...69)) ├── @ LambdaNode (location: (7,0)-(11,3))
│ ├── locals: [] │ ├── locals: []
│ ├── operator_loc: (41...43) = "->" │ ├── operator_loc: (7,0)-(7,2) = "->"
│ ├── opening_loc: (44...46) = "do" │ ├── opening_loc: (7,3)-(7,5) = "do"
│ ├── closing_loc: (66...69) = "end" │ ├── closing_loc: (11,0)-(11,3) = "end"
│ ├── parameters: ∅ │ ├── parameters: ∅
│ └── body: │ └── body:
│ @ BeginNode (location: (47...69)) │ @ BeginNode (location: (8,0)-(11,3))
│ ├── begin_keyword_loc: ∅ │ ├── begin_keyword_loc: ∅
│ ├── statements: ∅ │ ├── statements: ∅
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (47...53)) │ │ @ RescueNode (location: (8,0)-(8,6))
│ │ ├── keyword_loc: (47...53) = "rescue" │ │ ├── keyword_loc: (8,0)-(8,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: │ ├── else_clause:
│ │ @ ElseNode (location: (54...65)) │ │ @ ElseNode (location: (9,0)-(10,6))
│ │ ├── else_keyword_loc: (54...58) = "else" │ │ ├── else_keyword_loc: (9,0)-(9,4) = "else"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (59...65) = "ensure" │ │ └── end_keyword_loc: (10,0)-(10,6) = "ensure"
│ ├── ensure_clause: │ ├── ensure_clause:
│ │ @ EnsureNode (location: (59...69)) │ │ @ EnsureNode (location: (10,0)-(11,3))
│ │ ├── ensure_keyword_loc: (59...65) = "ensure" │ │ ├── ensure_keyword_loc: (10,0)-(10,6) = "ensure"
│ │ ├── statements: ∅ │ │ ├── statements: ∅
│ │ └── end_keyword_loc: (66...69) = "end" │ │ └── end_keyword_loc: (11,0)-(11,3) = "end"
│ └── end_keyword_loc: (66...69) = "end" │ └── end_keyword_loc: (11,0)-(11,3) = "end"
├── @ LambdaNode (location: (71...81)) ├── @ LambdaNode (location: (13,0)-(13,10))
│ ├── locals: [] │ ├── locals: []
│ ├── operator_loc: (71...73) = "->" │ ├── operator_loc: (13,0)-(13,2) = "->"
│ ├── opening_loc: (74...75) = "{" │ ├── opening_loc: (13,3)-(13,4) = "{"
│ ├── closing_loc: (80...81) = "}" │ ├── closing_loc: (13,9)-(13,10) = "}"
│ ├── parameters: ∅ │ ├── parameters: ∅
│ └── body: │ └── body:
│ @ StatementsNode (location: (76...79)) │ @ StatementsNode (location: (13,5)-(13,8))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (76...79)) │ └── @ CallNode (location: (13,5)-(13,8))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (76...79) = "foo" │ ├── message_loc: (13,5)-(13,8) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "foo" │ └── name: "foo"
├── @ LambdaNode (location: (83...98)) ├── @ LambdaNode (location: (15,0)-(15,15))
│ ├── locals: [] │ ├── locals: []
│ ├── operator_loc: (83...85) = "->" │ ├── operator_loc: (15,0)-(15,2) = "->"
│ ├── opening_loc: (86...88) = "do" │ ├── opening_loc: (15,3)-(15,5) = "do"
│ ├── closing_loc: (95...98) = "end" │ ├── closing_loc: (15,12)-(15,15) = "end"
│ ├── parameters: ∅ │ ├── parameters: ∅
│ └── body: │ └── body:
│ @ StatementsNode (location: (90...93)) │ @ StatementsNode (location: (15,7)-(15,10))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (90...93)) │ └── @ CallNode (location: (15,7)-(15,10))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (90...93) = "foo" │ ├── message_loc: (15,7)-(15,10) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "foo" │ └── name: "foo"
├── @ LambdaNode (location: (100...129)) ├── @ LambdaNode (location: (17,0)-(17,29))
│ ├── locals: [:a, :b, :c, :d, :e] │ ├── locals: [:a, :b, :c, :d, :e]
│ ├── operator_loc: (100...102) = "->" │ ├── operator_loc: (17,0)-(17,2) = "->"
│ ├── opening_loc: (124...125) = "{" │ ├── opening_loc: (17,24)-(17,25) = "{"
│ ├── closing_loc: (128...129) = "}" │ ├── closing_loc: (17,28)-(17,29) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (103...123)) │ │ @ BlockParametersNode (location: (17,3)-(17,23))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (103...123)) │ │ │ @ ParametersNode (location: (17,3)-(17,23))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (103...104)) │ │ │ │ └── @ RequiredParameterNode (location: (17,3)-(17,4))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (106...111)) │ │ │ │ └── @ OptionalParameterNode (location: (17,6)-(17,11))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (106...107) = "b" │ │ │ │ ├── name_loc: (17,6)-(17,7) = "b"
│ │ │ │ ├── operator_loc: (108...109) = "=" │ │ │ │ ├── operator_loc: (17,8)-(17,9) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (110...111)) │ │ │ │ @ IntegerNode (location: (17,10)-(17,11))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2) │ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (113...115)) │ │ │ │ ├── @ KeywordParameterNode (location: (17,13)-(17,15))
│ │ │ │ │ ├── name: :c │ │ │ │ │ ├── name: :c
│ │ │ │ │ ├── name_loc: (113...115) = "c:" │ │ │ │ │ ├── name_loc: (17,13)-(17,15) = "c:"
│ │ │ │ │ └── value: ∅ │ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (117...119)) │ │ │ │ └── @ KeywordParameterNode (location: (17,17)-(17,19))
│ │ │ │ ├── name: :d │ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (117...119) = "d:" │ │ │ │ ├── name_loc: (17,17)-(17,19) = "d:"
│ │ │ │ └── value: ∅ │ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (121...123)) │ │ │ @ BlockParameterNode (location: (17,21)-(17,23))
│ │ │ ├── name: :e │ │ │ ├── name: :e
│ │ │ ├── name_loc: (122...123) = "e" │ │ │ ├── name_loc: (17,22)-(17,23) = "e"
│ │ │ └── operator_loc: (121...122) = "&" │ │ │ └── operator_loc: (17,21)-(17,22) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅ │ │ └── closing_loc: ∅
│ └── body: │ └── body:
│ @ StatementsNode (location: (126...127)) │ @ StatementsNode (location: (17,26)-(17,27))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (126...127)) │ └── @ LocalVariableReadNode (location: (17,26)-(17,27))
│ ├── name: :a │ ├── name: :a
│ └── depth: 0 │ └── depth: 0
├── @ LambdaNode (location: (131...171)) ├── @ LambdaNode (location: (19,0)-(19,40))
│ ├── locals: [:a, :b, :c, :d, :e, :f, :g] │ ├── locals: [:a, :b, :c, :d, :e, :f, :g]
│ ├── operator_loc: (131...133) = "->" │ ├── operator_loc: (19,0)-(19,2) = "->"
│ ├── opening_loc: (166...167) = "{" │ ├── opening_loc: (19,35)-(19,36) = "{"
│ ├── closing_loc: (170...171) = "}" │ ├── closing_loc: (19,39)-(19,40) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (134...165)) │ │ @ BlockParametersNode (location: (19,3)-(19,34))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (135...164)) │ │ │ @ ParametersNode (location: (19,4)-(19,33))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (135...136)) │ │ │ │ └── @ RequiredParameterNode (location: (19,4)-(19,5))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (138...143)) │ │ │ │ └── @ OptionalParameterNode (location: (19,7)-(19,12))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (138...139) = "b" │ │ │ │ ├── name_loc: (19,7)-(19,8) = "b"
│ │ │ │ ├── operator_loc: (140...141) = "=" │ │ │ │ ├── operator_loc: (19,9)-(19,10) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (142...143)) │ │ │ │ @ IntegerNode (location: (19,11)-(19,12))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (145...147)) │ │ │ │ @ RestParameterNode (location: (19,14)-(19,16))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (146...147) = "c" │ │ │ │ ├── name_loc: (19,15)-(19,16) = "c"
│ │ │ │ └── operator_loc: (145...146) = "*" │ │ │ │ └── operator_loc: (19,14)-(19,15) = "*"
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2) │ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (149...151)) │ │ │ │ ├── @ KeywordParameterNode (location: (19,18)-(19,20))
│ │ │ │ │ ├── name: :d │ │ │ │ │ ├── name: :d
│ │ │ │ │ ├── name_loc: (149...151) = "d:" │ │ │ │ │ ├── name_loc: (19,18)-(19,20) = "d:"
│ │ │ │ │ └── value: ∅ │ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (153...155)) │ │ │ │ └── @ KeywordParameterNode (location: (19,22)-(19,24))
│ │ │ │ ├── name: :e │ │ │ │ ├── name: :e
│ │ │ │ ├── name_loc: (153...155) = "e:" │ │ │ │ ├── name_loc: (19,22)-(19,24) = "e:"
│ │ │ │ └── value: ∅ │ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest: │ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (157...160)) │ │ │ │ @ KeywordRestParameterNode (location: (19,26)-(19,29))
│ │ │ │ ├── name: :f │ │ │ │ ├── name: :f
│ │ │ │ ├── name_loc: (159...160) = "f" │ │ │ │ ├── name_loc: (19,28)-(19,29) = "f"
│ │ │ │ └── operator_loc: (157...159) = "**" │ │ │ │ └── operator_loc: (19,26)-(19,28) = "**"
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (162...164)) │ │ │ @ BlockParameterNode (location: (19,31)-(19,33))
│ │ │ ├── name: :g │ │ │ ├── name: :g
│ │ │ ├── name_loc: (163...164) = "g" │ │ │ ├── name_loc: (19,32)-(19,33) = "g"
│ │ │ └── operator_loc: (162...163) = "&" │ │ │ └── operator_loc: (19,31)-(19,32) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (134...135) = "(" │ │ ├── opening_loc: (19,3)-(19,4) = "("
│ │ └── closing_loc: (164...165) = ")" │ │ └── closing_loc: (19,33)-(19,34) = ")"
│ └── body: │ └── body:
│ @ StatementsNode (location: (168...169)) │ @ StatementsNode (location: (19,37)-(19,38))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (168...169)) │ └── @ LocalVariableReadNode (location: (19,37)-(19,38))
│ ├── name: :a │ ├── name: :a
│ └── depth: 0 │ └── depth: 0
├── @ LambdaNode (location: (173...218)) ├── @ LambdaNode (location: (21,0)-(23,3))
│ ├── locals: [:a, :b, :c, :d, :e, :f, :g] │ ├── locals: [:a, :b, :c, :d, :e, :f, :g]
│ ├── operator_loc: (173...175) = "->" │ ├── operator_loc: (21,0)-(21,2) = "->"
│ ├── opening_loc: (208...210) = "do" │ ├── opening_loc: (21,35)-(21,37) = "do"
│ ├── closing_loc: (215...218) = "end" │ ├── closing_loc: (23,0)-(23,3) = "end"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (176...207)) │ │ @ BlockParametersNode (location: (21,3)-(21,34))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (177...206)) │ │ │ @ ParametersNode (location: (21,4)-(21,33))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (177...178)) │ │ │ │ └── @ RequiredParameterNode (location: (21,4)-(21,5))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (180...185)) │ │ │ │ └── @ OptionalParameterNode (location: (21,7)-(21,12))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (180...181) = "b" │ │ │ │ ├── name_loc: (21,7)-(21,8) = "b"
│ │ │ │ ├── operator_loc: (182...183) = "=" │ │ │ │ ├── operator_loc: (21,9)-(21,10) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (184...185)) │ │ │ │ @ IntegerNode (location: (21,11)-(21,12))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (187...189)) │ │ │ │ @ RestParameterNode (location: (21,14)-(21,16))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (188...189) = "c" │ │ │ │ ├── name_loc: (21,15)-(21,16) = "c"
│ │ │ │ └── operator_loc: (187...188) = "*" │ │ │ │ └── operator_loc: (21,14)-(21,15) = "*"
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2) │ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (191...193)) │ │ │ │ ├── @ KeywordParameterNode (location: (21,18)-(21,20))
│ │ │ │ │ ├── name: :d │ │ │ │ │ ├── name: :d
│ │ │ │ │ ├── name_loc: (191...193) = "d:" │ │ │ │ │ ├── name_loc: (21,18)-(21,20) = "d:"
│ │ │ │ │ └── value: ∅ │ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (195...197)) │ │ │ │ └── @ KeywordParameterNode (location: (21,22)-(21,24))
│ │ │ │ ├── name: :e │ │ │ │ ├── name: :e
│ │ │ │ ├── name_loc: (195...197) = "e:" │ │ │ │ ├── name_loc: (21,22)-(21,24) = "e:"
│ │ │ │ └── value: ∅ │ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest: │ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (199...202)) │ │ │ │ @ KeywordRestParameterNode (location: (21,26)-(21,29))
│ │ │ │ ├── name: :f │ │ │ │ ├── name: :f
│ │ │ │ ├── name_loc: (201...202) = "f" │ │ │ │ ├── name_loc: (21,28)-(21,29) = "f"
│ │ │ │ └── operator_loc: (199...201) = "**" │ │ │ │ └── operator_loc: (21,26)-(21,28) = "**"
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (204...206)) │ │ │ @ BlockParameterNode (location: (21,31)-(21,33))
│ │ │ ├── name: :g │ │ │ ├── name: :g
│ │ │ ├── name_loc: (205...206) = "g" │ │ │ ├── name_loc: (21,32)-(21,33) = "g"
│ │ │ └── operator_loc: (204...205) = "&" │ │ │ └── operator_loc: (21,31)-(21,32) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (176...177) = "(" │ │ ├── opening_loc: (21,3)-(21,4) = "("
│ │ └── closing_loc: (206...207) = ")" │ │ └── closing_loc: (21,33)-(21,34) = ")"
│ └── body: │ └── body:
│ @ StatementsNode (location: (213...214)) │ @ StatementsNode (location: (22,2)-(22,3))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (213...214)) │ └── @ LocalVariableReadNode (location: (22,2)-(22,3))
│ ├── name: :a │ ├── name: :a
│ └── depth: 0 │ └── depth: 0
├── @ LambdaNode (location: (220...245)) ├── @ LambdaNode (location: (25,0)-(25,25))
│ ├── locals: [:a] │ ├── locals: [:a]
│ ├── operator_loc: (220...222) = "->" │ ├── operator_loc: (25,0)-(25,2) = "->"
│ ├── opening_loc: (227...228) = "{" │ ├── opening_loc: (25,7)-(25,8) = "{"
│ ├── closing_loc: (244...245) = "}" │ ├── closing_loc: (25,24)-(25,25) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (223...226)) │ │ @ BlockParametersNode (location: (25,3)-(25,6))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (224...225)) │ │ │ @ ParametersNode (location: (25,4)-(25,5))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (224...225)) │ │ │ │ └── @ RequiredParameterNode (location: (25,4)-(25,5))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -294,22 +294,22 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (223...224) = "(" │ │ ├── opening_loc: (25,3)-(25,4) = "("
│ │ └── closing_loc: (225...226) = ")" │ │ └── closing_loc: (25,5)-(25,6) = ")"
│ └── body: │ └── body:
│ @ StatementsNode (location: (229...243)) │ @ StatementsNode (location: (25,9)-(25,23))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ LambdaNode (location: (229...243)) │ └── @ LambdaNode (location: (25,9)-(25,23))
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── operator_loc: (229...231) = "->" │ ├── operator_loc: (25,9)-(25,11) = "->"
│ ├── opening_loc: (234...235) = "{" │ ├── opening_loc: (25,14)-(25,15) = "{"
│ ├── closing_loc: (242...243) = "}" │ ├── closing_loc: (25,22)-(25,23) = "}"
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (232...233)) │ │ @ BlockParametersNode (location: (25,12)-(25,13))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (232...233)) │ │ │ @ ParametersNode (location: (25,12)-(25,13))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (232...233)) │ │ │ │ └── @ RequiredParameterNode (location: (25,12)-(25,13))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -321,55 +321,55 @@
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅ │ │ └── closing_loc: ∅
│ └── body: │ └── body:
│ @ StatementsNode (location: (236...241)) │ @ StatementsNode (location: (25,16)-(25,21))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ CallNode (location: (236...241)) │ └── @ CallNode (location: (25,16)-(25,21))
│ ├── receiver: │ ├── receiver:
│ │ @ LocalVariableReadNode (location: (236...237)) │ │ @ LocalVariableReadNode (location: (25,16)-(25,17))
│ │ ├── name: :a │ │ ├── name: :a
│ │ └── depth: 1 │ │ └── depth: 1
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (238...239) = "*" │ ├── message_loc: (25,18)-(25,19) = "*"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (240...241)) │ │ @ ArgumentsNode (location: (25,20)-(25,21))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (240...241)) │ │ └── @ LocalVariableReadNode (location: (25,20)-(25,21))
│ │ ├── name: :b │ │ ├── name: :b
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "*" │ └── name: "*"
└── @ LambdaNode (location: (247...266)) └── @ LambdaNode (location: (27,0)-(27,19))
├── locals: [:a, :b, :c] ├── locals: [:a, :b, :c]
├── operator_loc: (247...249) = "->" ├── operator_loc: (27,0)-(27,2) = "->"
├── opening_loc: (263...264) = "{" ├── opening_loc: (27,16)-(27,17) = "{"
├── closing_loc: (265...266) = "}" ├── closing_loc: (27,18)-(27,19) = "}"
├── parameters: ├── parameters:
│ @ BlockParametersNode (location: (250...262)) │ @ BlockParametersNode (location: (27,3)-(27,15))
│ ├── parameters: │ ├── parameters:
│ │ @ ParametersNode (location: (251...261)) │ │ @ ParametersNode (location: (27,4)-(27,14))
│ │ ├── requireds: (length: 1) │ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredDestructuredParameterNode (location: (251...257)) │ │ │ └── @ RequiredDestructuredParameterNode (location: (27,4)-(27,10))
│ │ │ ├── parameters: (length: 2) │ │ │ ├── parameters: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (252...253)) │ │ │ │ ├── @ RequiredParameterNode (location: (27,5)-(27,6))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (255...256)) │ │ │ │ └── @ RequiredParameterNode (location: (27,8)-(27,9))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── opening_loc: (251...252) = "(" │ │ │ ├── opening_loc: (27,4)-(27,5) = "("
│ │ │ └── closing_loc: (256...257) = ")" │ │ │ └── closing_loc: (27,9)-(27,10) = ")"
│ │ ├── optionals: (length: 0) │ │ ├── optionals: (length: 0)
│ │ ├── rest: │ │ ├── rest:
│ │ │ @ RestParameterNode (location: (259...261)) │ │ │ @ RestParameterNode (location: (27,12)-(27,14))
│ │ │ ├── name: :c │ │ │ ├── name: :c
│ │ │ ├── name_loc: (260...261) = "c" │ │ │ ├── name_loc: (27,13)-(27,14) = "c"
│ │ │ └── operator_loc: (259...260) = "*" │ │ │ └── operator_loc: (27,12)-(27,13) = "*"
│ │ ├── posts: (length: 0) │ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0) │ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest: ∅ │ │ ├── keyword_rest: ∅
│ │ └── block: ∅ │ │ └── block: ∅
│ ├── locals: (length: 0) │ ├── locals: (length: 0)
│ ├── opening_loc: (250...251) = "(" │ ├── opening_loc: (27,3)-(27,4) = "("
│ └── closing_loc: (261...262) = ")" │ └── closing_loc: (27,14)-(27,15) = ")"
└── body: ∅ └── body: ∅

10
test/yarp/snapshots/range_begin_open_exclusive.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...4)) @ ProgramNode (location: (1,0)-(1,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...4)) @ StatementsNode (location: (1,0)-(1,4))
└── body: (length: 1) └── body: (length: 1)
└── @ RangeNode (location: (0...4)) └── @ RangeNode (location: (1,0)-(1,4))
├── left: ∅ ├── left: ∅
├── right: ├── right:
│ @ IntegerNode (location: (3...4)) │ @ IntegerNode (location: (1,3)-(1,4))
│ └── flags: decimal │ └── flags: decimal
├── operator_loc: (0...3) = "..." ├── operator_loc: (1,0)-(1,3) = "..."
└── flags: exclude_end └── flags: exclude_end

10
test/yarp/snapshots/range_begin_open_inclusive.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...3)) @ ProgramNode (location: (1,0)-(1,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...3)) @ StatementsNode (location: (1,0)-(1,3))
└── body: (length: 1) └── body: (length: 1)
└── @ RangeNode (location: (0...3)) └── @ RangeNode (location: (1,0)-(1,3))
├── left: ∅ ├── left: ∅
├── right: ├── right:
│ @ IntegerNode (location: (2...3)) │ @ IntegerNode (location: (1,2)-(1,3))
│ └── flags: decimal │ └── flags: decimal
├── operator_loc: (0...2) = ".." ├── operator_loc: (1,0)-(1,2) = ".."
└── flags: ∅ └── flags: ∅

10
test/yarp/snapshots/range_end_open_exclusive.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...4)) @ ProgramNode (location: (1,0)-(1,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...4)) @ StatementsNode (location: (1,0)-(1,4))
└── body: (length: 1) └── body: (length: 1)
└── @ RangeNode (location: (0...4)) └── @ RangeNode (location: (1,0)-(1,4))
├── left: ├── left:
│ @ IntegerNode (location: (0...1)) │ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal │ └── flags: decimal
├── right: ∅ ├── right: ∅
├── operator_loc: (1...4) = "..." ├── operator_loc: (1,1)-(1,4) = "..."
└── flags: exclude_end └── flags: exclude_end

10
test/yarp/snapshots/range_end_open_inclusive.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...3)) @ ProgramNode (location: (1,0)-(1,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...3)) @ StatementsNode (location: (1,0)-(1,3))
└── body: (length: 1) └── body: (length: 1)
└── @ RangeNode (location: (0...3)) └── @ RangeNode (location: (1,0)-(1,3))
├── left: ├── left:
│ @ IntegerNode (location: (0...1)) │ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal │ └── flags: decimal
├── right: ∅ ├── right: ∅
├── operator_loc: (1...3) = ".." ├── operator_loc: (1,1)-(1,3) = ".."
└── flags: ∅ └── flags: ∅

140
test/yarp/snapshots/ranges.txt
View file

@ -1,49 +1,49 @@
@ ProgramNode (location: (0...85)) @ ProgramNode (location: (1,0)-(17,5))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...85)) @ StatementsNode (location: (1,0)-(17,5))
└── body: (length: 9) └── body: (length: 9)
├── @ ParenthesesNode (location: (0...6)) ├── @ ParenthesesNode (location: (1,0)-(1,6))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (1...5)) │ │ @ StatementsNode (location: (1,1)-(1,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (1...5)) │ │ └── @ RangeNode (location: (1,1)-(1,5))
│ │ ├── left: ∅ │ │ ├── left: ∅
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (4...5)) │ │ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (1...4) = "..." │ │ ├── operator_loc: (1,1)-(1,4) = "..."
│ │ └── flags: exclude_end │ │ └── flags: exclude_end
│ ├── opening_loc: (0...1) = "(" │ ├── opening_loc: (1,0)-(1,1) = "("
│ └── closing_loc: (5...6) = ")" │ └── closing_loc: (1,5)-(1,6) = ")"
├── @ ParenthesesNode (location: (8...13)) ├── @ ParenthesesNode (location: (3,0)-(3,5))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (9...12)) │ │ @ StatementsNode (location: (3,1)-(3,4))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (9...12)) │ │ └── @ RangeNode (location: (3,1)-(3,4))
│ │ ├── left: ∅ │ │ ├── left: ∅
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (11...12)) │ │ │ @ IntegerNode (location: (3,3)-(3,4))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (9...11) = ".." │ │ ├── operator_loc: (3,1)-(3,3) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── opening_loc: (8...9) = "(" │ ├── opening_loc: (3,0)-(3,1) = "("
│ └── closing_loc: (12...13) = ")" │ └── closing_loc: (3,4)-(3,5) = ")"
├── @ RangeNode (location: (15...20)) ├── @ RangeNode (location: (5,0)-(5,5))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (15...16)) │ │ @ IntegerNode (location: (5,0)-(5,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (19...20)) │ │ @ IntegerNode (location: (5,4)-(5,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── operator_loc: (16...19) = "..." │ ├── operator_loc: (5,1)-(5,4) = "..."
│ └── flags: exclude_end │ └── flags: exclude_end
├── @ CallNode (location: (22...31)) ├── @ CallNode (location: (7,0)-(7,9))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (22...25)) │ │ @ CallNode (location: (7,0)-(7,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (22...25) = "foo" │ │ ├── message_loc: (7,0)-(7,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -51,110 +51,110 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (25...31) = "[...2]" │ ├── message_loc: (7,3)-(7,9) = "[...2]"
│ ├── opening_loc: (25...26) = "[" │ ├── opening_loc: (7,3)-(7,4) = "["
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (26...30)) │ │ @ ArgumentsNode (location: (7,4)-(7,8))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ RangeNode (location: (26...30)) │ │ └── @ RangeNode (location: (7,4)-(7,8))
│ │ ├── left: ∅ │ │ ├── left: ∅
│ │ ├── right: │ │ ├── right:
│ │ │ @ IntegerNode (location: (29...30)) │ │ │ @ IntegerNode (location: (7,7)-(7,8))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── operator_loc: (26...29) = "..." │ │ ├── operator_loc: (7,4)-(7,7) = "..."
│ │ └── flags: exclude_end │ │ └── flags: exclude_end
│ ├── closing_loc: (30...31) = "]" │ ├── closing_loc: (7,8)-(7,9) = "]"
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "[]" │ └── name: "[]"
├── @ HashNode (location: (33...48)) ├── @ HashNode (location: (9,0)-(9,15))
│ ├── opening_loc: (33...34) = "{" │ ├── opening_loc: (9,0)-(9,1) = "{"
│ ├── elements: (length: 1) │ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (35...46)) │ │ └── @ AssocNode (location: (9,2)-(9,13))
│ │ ├── key: │ │ ├── key:
│ │ │ @ SymbolNode (location: (35...39)) │ │ │ @ SymbolNode (location: (9,2)-(9,6))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (35...38) = "foo" │ │ │ ├── value_loc: (9,2)-(9,5) = "foo"
│ │ │ ├── closing_loc: (38...39) = ":" │ │ │ ├── closing_loc: (9,5)-(9,6) = ":"
│ │ │ └── unescaped: "foo" │ │ │ └── unescaped: "foo"
│ │ ├── value: │ │ ├── value:
│ │ │ @ RangeNode (location: (40...46)) │ │ │ @ RangeNode (location: (9,7)-(9,13))
│ │ │ ├── left: ∅ │ │ │ ├── left: ∅
│ │ │ ├── right: │ │ │ ├── right:
│ │ │ │ @ CallNode (location: (43...46)) │ │ │ │ @ CallNode (location: (9,10)-(9,13))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (43...46) = "bar" │ │ │ │ ├── message_loc: (9,10)-(9,13) = "bar"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bar" │ │ │ │ └── name: "bar"
│ │ │ ├── operator_loc: (40...43) = "..." │ │ │ ├── operator_loc: (9,7)-(9,10) = "..."
│ │ │ └── flags: exclude_end │ │ │ └── flags: exclude_end
│ │ └── operator_loc: ∅ │ │ └── operator_loc: ∅
│ └── closing_loc: (47...48) = "}" │ └── closing_loc: (9,14)-(9,15) = "}"
├── @ ParenthesesNode (location: (50...56)) ├── @ ParenthesesNode (location: (11,0)-(11,6))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (51...55)) │ │ @ StatementsNode (location: (11,1)-(11,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (51...55)) │ │ └── @ RangeNode (location: (11,1)-(11,5))
│ │ ├── left: │ │ ├── left:
│ │ │ @ IntegerNode (location: (51...52)) │ │ │ @ IntegerNode (location: (11,1)-(11,2))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── right: ∅ │ │ ├── right: ∅
│ │ ├── operator_loc: (52...55) = "..." │ │ ├── operator_loc: (11,2)-(11,5) = "..."
│ │ └── flags: exclude_end │ │ └── flags: exclude_end
│ ├── opening_loc: (50...51) = "(" │ ├── opening_loc: (11,0)-(11,1) = "("
│ └── closing_loc: (55...56) = ")" │ └── closing_loc: (11,5)-(11,6) = ")"
├── @ RangeNode (location: (58...62)) ├── @ RangeNode (location: (13,0)-(13,4))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (58...59)) │ │ @ IntegerNode (location: (13,0)-(13,1))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (61...62)) │ │ @ IntegerNode (location: (13,3)-(13,4))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── operator_loc: (59...61) = ".." │ ├── operator_loc: (13,1)-(13,3) = ".."
│ └── flags: ∅ │ └── flags: ∅
├── @ HashNode (location: (64...78)) ├── @ HashNode (location: (15,0)-(15,14))
│ ├── opening_loc: (64...65) = "{" │ ├── opening_loc: (15,0)-(15,1) = "{"
│ ├── elements: (length: 1) │ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (66...76)) │ │ └── @ AssocNode (location: (15,2)-(15,12))
│ │ ├── key: │ │ ├── key:
│ │ │ @ SymbolNode (location: (66...70)) │ │ │ @ SymbolNode (location: (15,2)-(15,6))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (66...69) = "foo" │ │ │ ├── value_loc: (15,2)-(15,5) = "foo"
│ │ │ ├── closing_loc: (69...70) = ":" │ │ │ ├── closing_loc: (15,5)-(15,6) = ":"
│ │ │ └── unescaped: "foo" │ │ │ └── unescaped: "foo"
│ │ ├── value: │ │ ├── value:
│ │ │ @ RangeNode (location: (71...76)) │ │ │ @ RangeNode (location: (15,7)-(15,12))
│ │ │ ├── left: ∅ │ │ │ ├── left: ∅
│ │ │ ├── right: │ │ │ ├── right:
│ │ │ │ @ CallNode (location: (73...76)) │ │ │ │ @ CallNode (location: (15,9)-(15,12))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (73...76) = "bar" │ │ │ │ ├── message_loc: (15,9)-(15,12) = "bar"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bar" │ │ │ │ └── name: "bar"
│ │ │ ├── operator_loc: (71...73) = ".." │ │ │ ├── operator_loc: (15,7)-(15,9) = ".."
│ │ │ └── flags: ∅ │ │ │ └── flags: ∅
│ │ └── operator_loc: ∅ │ │ └── operator_loc: ∅
│ └── closing_loc: (77...78) = "}" │ └── closing_loc: (15,13)-(15,14) = "}"
└── @ ParenthesesNode (location: (80...85)) └── @ ParenthesesNode (location: (17,0)-(17,5))
├── body: ├── body:
│ @ StatementsNode (location: (81...84)) │ @ StatementsNode (location: (17,1)-(17,4))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ RangeNode (location: (81...84)) │ └── @ RangeNode (location: (17,1)-(17,4))
│ ├── left: │ ├── left:
│ │ @ IntegerNode (location: (81...82)) │ │ @ IntegerNode (location: (17,1)-(17,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── right: ∅ │ ├── right: ∅
│ ├── operator_loc: (82...84) = ".." │ ├── operator_loc: (17,2)-(17,4) = ".."
│ └── flags: ∅ │ └── flags: ∅
├── opening_loc: (80...81) = "(" ├── opening_loc: (17,0)-(17,1) = "("
└── closing_loc: (84...85) = ")" └── closing_loc: (17,4)-(17,5) = ")"

196
test/yarp/snapshots/regex.txt
View file

@ -1,109 +1,109 @@
@ ProgramNode (location: (0...293)) @ ProgramNode (location: (1,0)-(30,13))
├── locals: [:foo] ├── locals: [:foo]
└── statements: └── statements:
@ StatementsNode (location: (0...293)) @ StatementsNode (location: (1,0)-(30,13))
└── body: (length: 14) └── body: (length: 14)
├── @ CallNode (location: (0...9)) ├── @ CallNode (location: (1,0)-(1,9))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...3) = "foo" │ ├── message_loc: (1,0)-(1,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...9)) │ │ @ ArgumentsNode (location: (1,4)-(1,9))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ RegularExpressionNode (location: (4...9)) │ │ └── @ RegularExpressionNode (location: (1,4)-(1,9))
│ │ ├── opening_loc: (4...5) = "/" │ │ ├── opening_loc: (1,4)-(1,5) = "/"
│ │ ├── content_loc: (5...8) = "bar" │ │ ├── content_loc: (1,5)-(1,8) = "bar"
│ │ ├── closing_loc: (8...9) = "/" │ │ ├── closing_loc: (1,8)-(1,9) = "/"
│ │ ├── unescaped: "bar" │ │ ├── unescaped: "bar"
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ RegularExpressionNode (location: (11...19)) ├── @ RegularExpressionNode (location: (3,0)-(3,8))
│ ├── opening_loc: (11...14) = "%r{" │ ├── opening_loc: (3,0)-(3,3) = "%r{"
│ ├── content_loc: (14...17) = "abc" │ ├── content_loc: (3,3)-(3,6) = "abc"
│ ├── closing_loc: (17...19) = "}i" │ ├── closing_loc: (3,6)-(3,8) = "}i"
│ ├── unescaped: "abc" │ ├── unescaped: "abc"
│ └── flags: ignore_case │ └── flags: ignore_case
├── @ RegularExpressionNode (location: (21...26)) ├── @ RegularExpressionNode (location: (5,0)-(5,5))
│ ├── opening_loc: (21...22) = "/" │ ├── opening_loc: (5,0)-(5,1) = "/"
│ ├── content_loc: (22...25) = "a\\b" │ ├── content_loc: (5,1)-(5,4) = "a\\b"
│ ├── closing_loc: (25...26) = "/" │ ├── closing_loc: (5,4)-(5,5) = "/"
│ ├── unescaped: "a\b" │ ├── unescaped: "a\b"
│ └── flags: ∅ │ └── flags: ∅
├── @ InterpolatedRegularExpressionNode (location: (28...39)) ├── @ InterpolatedRegularExpressionNode (location: (7,0)-(7,11))
│ ├── opening_loc: (28...29) = "/" │ ├── opening_loc: (7,0)-(7,1) = "/"
│ ├── parts: (length: 2) │ ├── parts: (length: 2)
│ │ ├── @ StringNode (location: (29...33)) │ │ ├── @ StringNode (location: (7,1)-(7,5))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (29...33) = "aaa " │ │ │ ├── content_loc: (7,1)-(7,5) = "aaa "
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa " │ │ │ └── unescaped: "aaa "
│ │ └── @ EmbeddedVariableNode (location: (33...38)) │ │ └── @ EmbeddedVariableNode (location: (7,5)-(7,10))
│ │ ├── operator_loc: (33...34) = "#" │ │ ├── operator_loc: (7,5)-(7,6) = "#"
│ │ └── variable: │ │ └── variable:
│ │ @ GlobalVariableReadNode (location: (34...38)) │ │ @ GlobalVariableReadNode (location: (7,6)-(7,10))
│ │ └── name: :$bbb │ │ └── name: :$bbb
│ ├── closing_loc: (38...39) = "/" │ ├── closing_loc: (7,10)-(7,11) = "/"
│ └── flags: ∅ │ └── flags: ∅
├── @ InterpolatedRegularExpressionNode (location: (41...57)) ├── @ InterpolatedRegularExpressionNode (location: (9,0)-(9,16))
│ ├── opening_loc: (41...42) = "/" │ ├── opening_loc: (9,0)-(9,1) = "/"
│ ├── parts: (length: 3) │ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (42...46)) │ │ ├── @ StringNode (location: (9,1)-(9,5))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (42...46) = "aaa " │ │ │ ├── content_loc: (9,1)-(9,5) = "aaa "
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa " │ │ │ └── unescaped: "aaa "
│ │ ├── @ EmbeddedStatementsNode (location: (46...52)) │ │ ├── @ EmbeddedStatementsNode (location: (9,5)-(9,11))
│ │ │ ├── opening_loc: (46...48) = "\#{" │ │ │ ├── opening_loc: (9,5)-(9,7) = "\#{"
│ │ │ ├── statements: │ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (48...51)) │ │ │ │ @ StatementsNode (location: (9,7)-(9,10))
│ │ │ │ └── body: (length: 1) │ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (48...51)) │ │ │ │ └── @ CallNode (location: (9,7)-(9,10))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (48...51) = "bbb" │ │ │ │ ├── message_loc: (9,7)-(9,10) = "bbb"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bbb" │ │ │ │ └── name: "bbb"
│ │ │ └── closing_loc: (51...52) = "}" │ │ │ └── closing_loc: (9,10)-(9,11) = "}"
│ │ └── @ StringNode (location: (52...56)) │ │ └── @ StringNode (location: (9,11)-(9,15))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (52...56) = " ccc" │ │ ├── content_loc: (9,11)-(9,15) = " ccc"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: " ccc" │ │ └── unescaped: " ccc"
│ ├── closing_loc: (56...57) = "/" │ ├── closing_loc: (9,15)-(9,16) = "/"
│ └── flags: ∅ │ └── flags: ∅
├── @ ArrayNode (location: (59...86)) ├── @ ArrayNode (location: (11,0)-(11,27))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ MatchWriteNode (location: (60...80)) │ │ ├── @ MatchWriteNode (location: (11,1)-(11,21))
│ │ │ ├── call: │ │ │ ├── call:
│ │ │ │ @ CallNode (location: (60...80)) │ │ │ │ @ CallNode (location: (11,1)-(11,21))
│ │ │ │ ├── receiver: │ │ │ │ ├── receiver:
│ │ │ │ │ @ RegularExpressionNode (location: (60...73)) │ │ │ │ │ @ RegularExpressionNode (location: (11,1)-(11,14))
│ │ │ │ │ ├── opening_loc: (60...61) = "/" │ │ │ │ │ ├── opening_loc: (11,1)-(11,2) = "/"
│ │ │ │ │ ├── content_loc: (61...72) = "(?<foo>bar)" │ │ │ │ │ ├── content_loc: (11,2)-(11,13) = "(?<foo>bar)"
│ │ │ │ │ ├── closing_loc: (72...73) = "/" │ │ │ │ │ ├── closing_loc: (11,13)-(11,14) = "/"
│ │ │ │ │ ├── unescaped: "(?<foo>bar)" │ │ │ │ │ ├── unescaped: "(?<foo>bar)"
│ │ │ │ │ └── flags: ∅ │ │ │ │ │ └── flags: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (74...76) = "=~" │ │ │ │ ├── message_loc: (11,15)-(11,17) = "=~"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: │ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (77...80)) │ │ │ │ │ @ ArgumentsNode (location: (11,18)-(11,21))
│ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (77...80)) │ │ │ │ │ └── @ CallNode (location: (11,18)-(11,21))
│ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (77...80) = "baz" │ │ │ │ │ ├── message_loc: (11,18)-(11,21) = "baz"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
@ -115,95 +115,95 @@
│ │ │ │ ├── flags: ∅ │ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "=~" │ │ │ │ └── name: "=~"
│ │ │ └── locals: [:foo] │ │ │ └── locals: [:foo]
│ │ └── @ LocalVariableReadNode (location: (82...85)) │ │ └── @ LocalVariableReadNode (location: (11,23)-(11,26))
│ │ ├── name: :foo │ │ ├── name: :foo
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── opening_loc: (59...60) = "[" │ ├── opening_loc: (11,0)-(11,1) = "["
│ └── closing_loc: (85...86) = "]" │ └── closing_loc: (11,26)-(11,27) = "]"
├── @ RegularExpressionNode (location: (88...94)) ├── @ RegularExpressionNode (location: (13,0)-(13,6))
│ ├── opening_loc: (88...89) = "/" │ ├── opening_loc: (13,0)-(13,1) = "/"
│ ├── content_loc: (89...92) = "abc" │ ├── content_loc: (13,1)-(13,4) = "abc"
│ ├── closing_loc: (92...94) = "/i" │ ├── closing_loc: (13,4)-(13,6) = "/i"
│ ├── unescaped: "abc" │ ├── unescaped: "abc"
│ └── flags: ignore_case │ └── flags: ignore_case
├── @ RegularExpressionNode (location: (96...122)) ├── @ RegularExpressionNode (location: (15,0)-(15,26))
│ ├── opening_loc: (96...99) = "%r/" │ ├── opening_loc: (15,0)-(15,3) = "%r/"
│ ├── content_loc: (99...120) = "[a-z$._?][\\w$.?\#@~]*:" │ ├── content_loc: (15,3)-(15,24) = "[a-z$._?][\\w$.?\#@~]*:"
│ ├── closing_loc: (120...122) = "/i" │ ├── closing_loc: (15,24)-(15,26) = "/i"
│ ├── unescaped: "[a-z$._?][w$.?\#@~]*:" │ ├── unescaped: "[a-z$._?][w$.?\#@~]*:"
│ └── flags: ignore_case │ └── flags: ignore_case
├── @ RegularExpressionNode (location: (124...161)) ├── @ RegularExpressionNode (location: (17,0)-(17,37))
│ ├── opening_loc: (124...127) = "%r/" │ ├── opening_loc: (17,0)-(17,3) = "%r/"
│ ├── content_loc: (127...159) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)" │ ├── content_loc: (17,3)-(17,35) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
│ ├── closing_loc: (159...161) = "/i" │ ├── closing_loc: (17,35)-(17,37) = "/i"
│ ├── unescaped: "([a-z$._?][w$.?\#@~]*)( +)(equ)" │ ├── unescaped: "([a-z$._?][w$.?\#@~]*)( +)(equ)"
│ └── flags: ignore_case │ └── flags: ignore_case
├── @ RegularExpressionNode (location: (163...188)) ├── @ RegularExpressionNode (location: (19,0)-(19,25))
│ ├── opening_loc: (163...166) = "%r/" │ ├── opening_loc: (19,0)-(19,3) = "%r/"
│ ├── content_loc: (166...186) = "[a-z$._?][\\w$.?\#@~]*" │ ├── content_loc: (19,3)-(19,23) = "[a-z$._?][\\w$.?\#@~]*"
│ ├── closing_loc: (186...188) = "/i" │ ├── closing_loc: (19,23)-(19,25) = "/i"
│ ├── unescaped: "[a-z$._?][w$.?\#@~]*" │ ├── unescaped: "[a-z$._?][w$.?\#@~]*"
│ └── flags: ignore_case │ └── flags: ignore_case
├── @ RegularExpressionNode (location: (190...249)) ├── @ RegularExpressionNode (location: (21,0)-(24,1))
│ ├── opening_loc: (190...193) = "%r(" │ ├── opening_loc: (21,0)-(21,3) = "%r("
│ ├── content_loc: (193...248) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\\w\#$%_']+)\n" │ ├── content_loc: (21,3)-(23,0) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\\w\#$%_']+)\n"
│ ├── closing_loc: (248...249) = ")" │ ├── closing_loc: (24,0)-(24,1) = ")"
│ ├── unescaped: "\n(?:[w\#$%_']|()|(,)|[]|[0-9])*\n (?:[w\#$%_']+)\n" │ ├── unescaped: "\n(?:[w\#$%_']|()|(,)|[]|[0-9])*\n (?:[w\#$%_']+)\n"
│ └── flags: ∅ │ └── flags: ∅
├── @ CallNode (location: (251...267)) ├── @ CallNode (location: (26,0)-(26,16))
│ ├── receiver: │ ├── receiver:
│ │ @ RegularExpressionNode (location: (251...259)) │ │ @ RegularExpressionNode (location: (26,0)-(26,8))
│ │ ├── opening_loc: (251...252) = "/" │ │ ├── opening_loc: (26,0)-(26,1) = "/"
│ │ ├── content_loc: (252...258) = "(?#\\))" │ │ ├── content_loc: (26,1)-(26,7) = "(?#\\))"
│ │ ├── closing_loc: (258...259) = "/" │ │ ├── closing_loc: (26,7)-(26,8) = "/"
│ │ ├── unescaped: "(?#))" │ │ ├── unescaped: "(?#))"
│ │ └── flags: ∅ │ │ └── flags: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (260...262) = "=~" │ ├── message_loc: (26,9)-(26,11) = "=~"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (263...267)) │ │ @ ArgumentsNode (location: (26,12)-(26,16))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ StringNode (location: (263...267)) │ │ └── @ StringNode (location: (26,12)-(26,16))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (263...264) = "\"" │ │ ├── opening_loc: (26,12)-(26,13) = "\""
│ │ ├── content_loc: (264...266) = "hi" │ │ ├── content_loc: (26,13)-(26,15) = "hi"
│ │ ├── closing_loc: (266...267) = "\"" │ │ ├── closing_loc: (26,15)-(26,16) = "\""
│ │ └── unescaped: "hi" │ │ └── unescaped: "hi"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "=~" │ └── name: "=~"
├── @ RegularExpressionNode (location: (269...278)) ├── @ RegularExpressionNode (location: (28,0)-(28,9))
│ ├── opening_loc: (269...272) = "%r#" │ ├── opening_loc: (28,0)-(28,3) = "%r#"
│ ├── content_loc: (272...277) = "pound" │ ├── content_loc: (28,3)-(28,8) = "pound"
│ ├── closing_loc: (277...278) = "#" │ ├── closing_loc: (28,8)-(28,9) = "#"
│ ├── unescaped: "pound" │ ├── unescaped: "pound"
│ └── flags: ∅ │ └── flags: ∅
└── @ InterpolatedRegularExpressionNode (location: (280...293)) └── @ InterpolatedRegularExpressionNode (location: (30,0)-(30,13))
├── opening_loc: (280...281) = "/" ├── opening_loc: (30,0)-(30,1) = "/"
├── parts: (length: 2) ├── parts: (length: 2)
│ ├── @ StringNode (location: (281...285)) │ ├── @ StringNode (location: (30,1)-(30,5))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (281...285) = "aaa " │ │ ├── content_loc: (30,1)-(30,5) = "aaa "
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "aaa " │ │ └── unescaped: "aaa "
│ └── @ EmbeddedStatementsNode (location: (285...291)) │ └── @ EmbeddedStatementsNode (location: (30,5)-(30,11))
│ ├── opening_loc: (285...287) = "\#{" │ ├── opening_loc: (30,5)-(30,7) = "\#{"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (287...290)) │ │ @ StatementsNode (location: (30,7)-(30,10))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (287...290)) │ │ └── @ CallNode (location: (30,7)-(30,10))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (287...290) = "bbb" │ │ ├── message_loc: (30,7)-(30,10) = "bbb"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bbb" │ │ └── name: "bbb"
│ └── closing_loc: (290...291) = "}" │ └── closing_loc: (30,10)-(30,11) = "}"
├── closing_loc: (291...293) = "/o" ├── closing_loc: (30,11)-(30,13) = "/o"
└── flags: once └── flags: once

270
test/yarp/snapshots/rescue.txt
View file

@ -1,125 +1,125 @@
@ ProgramNode (location: (0...316)) @ ProgramNode (location: (1,0)-(31,3))
├── locals: [:a] ├── locals: [:a]
└── statements: └── statements:
@ StatementsNode (location: (0...316)) @ StatementsNode (location: (1,0)-(31,3))
└── body: (length: 12) └── body: (length: 12)
├── @ RescueModifierNode (location: (0...14)) ├── @ RescueModifierNode (location: (1,0)-(1,14))
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (0...3)) │ │ @ CallNode (location: (1,0)-(1,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "foo" │ │ ├── message_loc: (1,0)-(1,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── keyword_loc: (4...10) = "rescue" │ ├── keyword_loc: (1,4)-(1,10) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ NilNode (location: (11...14)) │ @ NilNode (location: (1,11)-(1,14))
├── @ RescueModifierNode (location: (16...30)) ├── @ RescueModifierNode (location: (3,0)-(4,3))
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (16...19)) │ │ @ CallNode (location: (3,0)-(3,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (16...19) = "foo" │ │ ├── message_loc: (3,0)-(3,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── keyword_loc: (20...26) = "rescue" │ ├── keyword_loc: (3,4)-(3,10) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ NilNode (location: (27...30)) │ @ NilNode (location: (4,0)-(4,3))
├── @ RescueModifierNode (location: (32...48)) ├── @ RescueModifierNode (location: (6,0)-(6,16))
│ ├── expression: │ ├── expression:
│ │ @ BreakNode (location: (32...37)) │ │ @ BreakNode (location: (6,0)-(6,5))
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ └── keyword_loc: (32...37) = "break" │ │ └── keyword_loc: (6,0)-(6,5) = "break"
│ ├── keyword_loc: (38...44) = "rescue" │ ├── keyword_loc: (6,6)-(6,12) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ NilNode (location: (45...48)) │ @ NilNode (location: (6,13)-(6,16))
├── @ RescueModifierNode (location: (50...65)) ├── @ RescueModifierNode (location: (8,0)-(8,15))
│ ├── expression: │ ├── expression:
│ │ @ NextNode (location: (50...54)) │ │ @ NextNode (location: (8,0)-(8,4))
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ └── keyword_loc: (50...54) = "next" │ │ └── keyword_loc: (8,0)-(8,4) = "next"
│ ├── keyword_loc: (55...61) = "rescue" │ ├── keyword_loc: (8,5)-(8,11) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ NilNode (location: (62...65)) │ @ NilNode (location: (8,12)-(8,15))
├── @ RescueModifierNode (location: (67...84)) ├── @ RescueModifierNode (location: (10,0)-(10,17))
│ ├── expression: │ ├── expression:
│ │ @ ReturnNode (location: (67...73)) │ │ @ ReturnNode (location: (10,0)-(10,6))
│ │ ├── keyword_loc: (67...73) = "return" │ │ ├── keyword_loc: (10,0)-(10,6) = "return"
│ │ └── arguments: ∅ │ │ └── arguments: ∅
│ ├── keyword_loc: (74...80) = "rescue" │ ├── keyword_loc: (10,7)-(10,13) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ NilNode (location: (81...84)) │ @ NilNode (location: (10,14)-(10,17))
├── @ RescueModifierNode (location: (86...105)) ├── @ RescueModifierNode (location: (12,0)-(12,19))
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (86...89)) │ │ @ CallNode (location: (12,0)-(12,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (86...89) = "foo" │ │ ├── message_loc: (12,0)-(12,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── keyword_loc: (90...96) = "rescue" │ ├── keyword_loc: (12,4)-(12,10) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ OrNode (location: (97...105)) │ @ OrNode (location: (12,11)-(12,19))
│ ├── left: │ ├── left:
│ │ @ NilNode (location: (97...100)) │ │ @ NilNode (location: (12,11)-(12,14))
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (104...105)) │ │ @ IntegerNode (location: (12,18)-(12,19))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (101...103) = "||" │ └── operator_loc: (12,15)-(12,17) = "||"
├── @ RescueModifierNode (location: (107...129)) ├── @ RescueModifierNode (location: (14,0)-(14,22))
│ ├── expression: │ ├── expression:
│ │ @ CallNode (location: (107...110)) │ │ @ CallNode (location: (14,0)-(14,3))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (107...110) = "foo" │ │ ├── message_loc: (14,0)-(14,3) = "foo"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "foo" │ │ └── name: "foo"
│ ├── keyword_loc: (111...117) = "rescue" │ ├── keyword_loc: (14,4)-(14,10) = "rescue"
│ └── rescue_expression: │ └── rescue_expression:
│ @ IfNode (location: (118...129)) │ @ IfNode (location: (14,11)-(14,22))
│ ├── if_keyword_loc: ∅ │ ├── if_keyword_loc: ∅
│ ├── predicate: │ ├── predicate:
│ │ @ NilNode (location: (118...121)) │ │ @ NilNode (location: (14,11)-(14,14))
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (124...125)) │ │ @ StatementsNode (location: (14,17)-(14,18))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (124...125)) │ │ └── @ IntegerNode (location: (14,17)-(14,18))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── consequent: │ ├── consequent:
│ │ @ ElseNode (location: (126...129)) │ │ @ ElseNode (location: (14,19)-(14,22))
│ │ ├── else_keyword_loc: (126...127) = ":" │ │ ├── else_keyword_loc: (14,19)-(14,20) = ":"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (128...129)) │ │ │ @ StatementsNode (location: (14,21)-(14,22))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (128...129)) │ │ │ └── @ IntegerNode (location: (14,21)-(14,22))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── end_keyword_loc: ∅ │ │ └── end_keyword_loc: ∅
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
├── @ BeginNode (location: (131...155)) ├── @ BeginNode (location: (16,0)-(16,24))
│ ├── begin_keyword_loc: (131...136) = "begin" │ ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (138...139)) │ │ @ StatementsNode (location: (16,7)-(16,8))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (138...139)) │ │ └── @ CallNode (location: (16,7)-(16,8))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (138...139) = "a" │ │ ├── message_loc: (16,7)-(16,8) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -127,16 +127,16 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (141...150)) │ │ @ RescueNode (location: (16,10)-(16,19))
│ │ ├── keyword_loc: (141...147) = "rescue" │ │ ├── keyword_loc: (16,10)-(16,16) = "rescue"
│ │ ├── exceptions: (length: 1) │ │ ├── exceptions: (length: 1)
│ │ │ └── @ SplatNode (location: (148...150)) │ │ │ └── @ SplatNode (location: (16,17)-(16,19))
│ │ │ ├── operator_loc: (148...149) = "*" │ │ │ ├── operator_loc: (16,17)-(16,18) = "*"
│ │ │ └── expression: │ │ │ └── expression:
│ │ │ @ CallNode (location: (149...150)) │ │ │ @ CallNode (location: (16,18)-(16,19))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (149...150) = "b" │ │ │ ├── message_loc: (16,18)-(16,19) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -149,23 +149,23 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (152...155) = "end" │ └── end_keyword_loc: (16,21)-(16,24) = "end"
├── @ CallNode (location: (157...212)) ├── @ CallNode (location: (18,0)-(20,3))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (157...160) = "foo" │ ├── message_loc: (18,0)-(18,3) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (161...212)) │ │ @ BlockNode (location: (18,4)-(20,3))
│ │ ├── locals: [:x] │ │ ├── locals: [:x]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (164...167)) │ │ │ @ BlockParametersNode (location: (18,7)-(18,10))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (165...166)) │ │ │ │ @ ParametersNode (location: (18,8)-(18,9))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (165...166)) │ │ │ │ │ └── @ RequiredParameterNode (location: (18,8)-(18,9))
│ │ │ │ │ └── name: :x │ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -174,58 +174,58 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (164...165) = "|" │ │ │ ├── opening_loc: (18,7)-(18,8) = "|"
│ │ │ └── closing_loc: (166...167) = "|" │ │ │ └── closing_loc: (18,9)-(18,10) = "|"
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (170...208)) │ │ │ @ StatementsNode (location: (19,2)-(19,40))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ RescueModifierNode (location: (170...208)) │ │ │ └── @ RescueModifierNode (location: (19,2)-(19,40))
│ │ │ ├── expression: │ │ │ ├── expression:
│ │ │ │ @ CallNode (location: (170...176)) │ │ │ │ @ CallNode (location: (19,2)-(19,8))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (170...173) = "bar" │ │ │ │ ├── message_loc: (19,2)-(19,5) = "bar"
│ │ │ │ ├── opening_loc: (173...174) = "(" │ │ │ │ ├── opening_loc: (19,5)-(19,6) = "("
│ │ │ │ ├── arguments: │ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (174...175)) │ │ │ │ │ @ ArgumentsNode (location: (19,6)-(19,7))
│ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (174...175)) │ │ │ │ │ └── @ CallNode (location: (19,6)-(19,7))
│ │ │ │ │ ├── receiver: ∅ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (174...175) = "y" │ │ │ │ │ ├── message_loc: (19,6)-(19,7) = "y"
│ │ │ │ │ ├── opening_loc: ∅ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block: ∅ │ │ │ │ │ ├── block: ∅
│ │ │ │ │ ├── flags: variable_call │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ └── name: "y" │ │ │ │ │ └── name: "y"
│ │ │ │ ├── closing_loc: (175...176) = ")" │ │ │ │ ├── closing_loc: (19,7)-(19,8) = ")"
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: ∅ │ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "bar" │ │ │ │ └── name: "bar"
│ │ │ ├── keyword_loc: (177...183) = "rescue" │ │ │ ├── keyword_loc: (19,9)-(19,15) = "rescue"
│ │ │ └── rescue_expression: │ │ │ └── rescue_expression:
│ │ │ @ CallNode (location: (184...208)) │ │ │ @ CallNode (location: (19,16)-(19,40))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (184...197) = "ArgumentError" │ │ │ ├── message_loc: (19,16)-(19,29) = "ArgumentError"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: │ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (198...208)) │ │ │ │ @ ArgumentsNode (location: (19,30)-(19,40))
│ │ │ │ └── arguments: (length: 1) │ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ CallNode (location: (198...208)) │ │ │ │ └── @ CallNode (location: (19,30)-(19,40))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (198...202) = "fail" │ │ │ │ ├── message_loc: (19,30)-(19,34) = "fail"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: │ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (203...208)) │ │ │ │ │ @ ArgumentsNode (location: (19,35)-(19,40))
│ │ │ │ │ └── arguments: (length: 1) │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ StringNode (location: (203...208)) │ │ │ │ │ └── @ StringNode (location: (19,35)-(19,40))
│ │ │ │ │ ├── flags: ∅ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ ├── opening_loc: (203...204) = "\"" │ │ │ │ │ ├── opening_loc: (19,35)-(19,36) = "\""
│ │ │ │ │ ├── content_loc: (204...207) = "baz" │ │ │ │ │ ├── content_loc: (19,36)-(19,39) = "baz"
│ │ │ │ │ ├── closing_loc: (207...208) = "\"" │ │ │ │ │ ├── closing_loc: (19,39)-(19,40) = "\""
│ │ │ │ │ └── unescaped: "baz" │ │ │ │ │ └── unescaped: "baz"
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
@ -235,41 +235,41 @@
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "ArgumentError" │ │ │ └── name: "ArgumentError"
│ │ ├── opening_loc: (161...163) = "do" │ │ ├── opening_loc: (18,4)-(18,6) = "do"
│ │ └── closing_loc: (209...212) = "end" │ │ └── closing_loc: (20,0)-(20,3) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
├── @ IfNode (location: (214...245)) ├── @ IfNode (location: (22,0)-(24,3))
│ ├── if_keyword_loc: (214...216) = "if" │ ├── if_keyword_loc: (22,0)-(22,2) = "if"
│ ├── predicate: │ ├── predicate:
│ │ @ LocalVariableWriteNode (location: (217...235)) │ │ @ LocalVariableWriteNode (location: (22,3)-(22,21))
│ │ ├── name: :a │ │ ├── name: :a
│ │ ├── depth: 0 │ │ ├── depth: 0
│ │ ├── name_loc: (217...218) = "a" │ │ ├── name_loc: (22,3)-(22,4) = "a"
│ │ ├── value: │ │ ├── value:
│ │ │ @ RescueModifierNode (location: (221...235)) │ │ │ @ RescueModifierNode (location: (22,7)-(22,21))
│ │ │ ├── expression: │ │ │ ├── expression:
│ │ │ │ @ CallNode (location: (221...224)) │ │ │ │ @ CallNode (location: (22,7)-(22,10))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (221...224) = "foo" │ │ │ │ ├── message_loc: (22,7)-(22,10) = "foo"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅ │ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call │ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "foo" │ │ │ │ └── name: "foo"
│ │ │ ├── keyword_loc: (225...231) = "rescue" │ │ │ ├── keyword_loc: (22,11)-(22,17) = "rescue"
│ │ │ └── rescue_expression: │ │ │ └── rescue_expression:
│ │ │ @ NilNode (location: (232...235)) │ │ │ @ NilNode (location: (22,18)-(22,21))
│ │ └── operator_loc: (219...220) = "=" │ │ └── operator_loc: (22,5)-(22,6) = "="
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (238...241)) │ │ @ StatementsNode (location: (23,2)-(23,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (238...241)) │ │ └── @ CallNode (location: (23,2)-(23,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (238...241) = "bar" │ │ ├── message_loc: (23,2)-(23,5) = "bar"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -277,76 +277,76 @@
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "bar" │ │ └── name: "bar"
│ ├── consequent: ∅ │ ├── consequent: ∅
│ └── end_keyword_loc: (242...245) = "end" │ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ DefNode (location: (247...291)) ├── @ DefNode (location: (26,0)-(26,44))
│ ├── name: :some_method │ ├── name: :some_method
│ ├── name_loc: (251...262) = "some_method" │ ├── name_loc: (26,4)-(26,15) = "some_method"
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (265...291)) │ │ @ StatementsNode (location: (26,18)-(26,44))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (265...291)) │ │ └── @ CallNode (location: (26,18)-(26,44))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (265...277) = "other_method" │ │ ├── message_loc: (26,18)-(26,30) = "other_method"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (278...291)) │ │ │ @ ArgumentsNode (location: (26,31)-(26,44))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ RescueModifierNode (location: (278...291)) │ │ │ └── @ RescueModifierNode (location: (26,31)-(26,44))
│ │ │ ├── expression: │ │ │ ├── expression:
│ │ │ │ @ IntegerNode (location: (278...280)) │ │ │ │ @ IntegerNode (location: (26,31)-(26,33))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── keyword_loc: (281...287) = "rescue" │ │ │ ├── keyword_loc: (26,34)-(26,40) = "rescue"
│ │ │ └── rescue_expression: │ │ │ └── rescue_expression:
│ │ │ @ NilNode (location: (288...291)) │ │ │ @ NilNode (location: (26,41)-(26,44))
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "other_method" │ │ └── name: "other_method"
│ ├── locals: [] │ ├── locals: []
│ ├── def_keyword_loc: (247...250) = "def" │ ├── def_keyword_loc: (26,0)-(26,3) = "def"
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── lparen_loc: ∅ │ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅ │ ├── rparen_loc: ∅
│ ├── equal_loc: (263...264) = "=" │ ├── equal_loc: (26,16)-(26,17) = "="
│ └── end_keyword_loc: ∅ │ └── end_keyword_loc: ∅
└── @ DefNode (location: (293...316)) └── @ DefNode (location: (28,0)-(31,3))
├── name: :a ├── name: :a
├── name_loc: (297...298) = "a" ├── name_loc: (28,4)-(28,5) = "a"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ∅ ├── parameters: ∅
├── body: ├── body:
│ @ BeginNode (location: (301...316)) │ @ BeginNode (location: (29,2)-(31,3))
│ ├── begin_keyword_loc: ∅ │ ├── begin_keyword_loc: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (301...305)) │ │ @ StatementsNode (location: (29,2)-(29,6))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (301...305)) │ │ └── @ CallNode (location: (29,2)-(29,6))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (301...302) = "a" │ │ ├── message_loc: (29,2)-(29,3) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: │ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (303...305)) │ │ │ @ ArgumentsNode (location: (29,4)-(29,6))
│ │ │ └── arguments: (length: 1) │ │ │ └── arguments: (length: 1)
│ │ │ └── @ KeywordHashNode (location: (303...305)) │ │ │ └── @ KeywordHashNode (location: (29,4)-(29,6))
│ │ │ └── elements: (length: 1) │ │ │ └── elements: (length: 1)
│ │ │ └── @ AssocNode (location: (303...305)) │ │ │ └── @ AssocNode (location: (29,4)-(29,6))
│ │ │ ├── key: │ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (303...305)) │ │ │ │ @ SymbolNode (location: (29,4)-(29,6))
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (303...304) = "b" │ │ │ │ ├── value_loc: (29,4)-(29,5) = "b"
│ │ │ │ ├── closing_loc: (304...305) = ":" │ │ │ │ ├── closing_loc: (29,5)-(29,6) = ":"
│ │ │ │ └── unescaped: "b" │ │ │ │ └── unescaped: "b"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (303...305)) │ │ │ │ @ ImplicitNode (location: (29,4)-(29,6))
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (303...305)) │ │ │ │ @ CallNode (location: (29,4)-(29,6))
│ │ │ │ ├── receiver: ∅ │ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (303...304) = "b" │ │ │ │ ├── message_loc: (29,4)-(29,5) = "b"
│ │ │ │ ├── opening_loc: ∅ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅ │ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
@ -359,8 +359,8 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "a" │ │ └── name: "a"
│ ├── rescue_clause: │ ├── rescue_clause:
│ │ @ RescueNode (location: (306...312)) │ │ @ RescueNode (location: (30,0)-(30,6))
│ │ ├── keyword_loc: (306...312) = "rescue" │ │ ├── keyword_loc: (30,0)-(30,6) = "rescue"
│ │ ├── exceptions: (length: 0) │ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── reference: ∅ │ │ ├── reference: ∅
@ -368,11 +368,11 @@
│ │ └── consequent: ∅ │ │ └── consequent: ∅
│ ├── else_clause: ∅ │ ├── else_clause: ∅
│ ├── ensure_clause: ∅ │ ├── ensure_clause: ∅
│ └── end_keyword_loc: (313...316) = "end" │ └── end_keyword_loc: (31,0)-(31,3) = "end"
├── locals: [] ├── locals: []
├── def_keyword_loc: (293...296) = "def" ├── def_keyword_loc: (28,0)-(28,3) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: ∅ ├── lparen_loc: ∅
├── rparen_loc: ∅ ├── rparen_loc: ∅
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (313...316) = "end" └── end_keyword_loc: (31,0)-(31,3) = "end"

152
test/yarp/snapshots/return.txt
View file

@ -1,128 +1,128 @@
@ ProgramNode (location: (0...139)) @ ProgramNode (location: (1,0)-(23,9))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...139)) @ StatementsNode (location: (1,0)-(23,9))
└── body: (length: 10) └── body: (length: 10)
├── @ ReturnNode (location: (0...6)) ├── @ ReturnNode (location: (1,0)-(1,6))
│ ├── keyword_loc: (0...6) = "return" │ ├── keyword_loc: (1,0)-(1,6) = "return"
│ └── arguments: ∅ │ └── arguments: ∅
├── @ ReturnNode (location: (8...28)) ├── @ ReturnNode (location: (3,0)-(3,20))
│ ├── keyword_loc: (8...14) = "return" │ ├── keyword_loc: (3,0)-(3,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (15...28)) │ @ ArgumentsNode (location: (3,7)-(3,20))
│ └── arguments: (length: 3) │ └── arguments: (length: 3)
│ ├── @ ParenthesesNode (location: (15...18)) │ ├── @ ParenthesesNode (location: (3,7)-(3,10))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (16...17)) │ │ │ @ StatementsNode (location: (3,8)-(3,9))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (16...17)) │ │ │ └── @ IntegerNode (location: (3,8)-(3,9))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (15...16) = "(" │ │ ├── opening_loc: (3,7)-(3,8) = "("
│ │ └── closing_loc: (17...18) = ")" │ │ └── closing_loc: (3,9)-(3,10) = ")"
│ ├── @ ParenthesesNode (location: (20...23)) │ ├── @ ParenthesesNode (location: (3,12)-(3,15))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (21...22)) │ │ │ @ StatementsNode (location: (3,13)-(3,14))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (21...22)) │ │ │ └── @ IntegerNode (location: (3,13)-(3,14))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (20...21) = "(" │ │ ├── opening_loc: (3,12)-(3,13) = "("
│ │ └── closing_loc: (22...23) = ")" │ │ └── closing_loc: (3,14)-(3,15) = ")"
│ └── @ ParenthesesNode (location: (25...28)) │ └── @ ParenthesesNode (location: (3,17)-(3,20))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (26...27)) │ │ @ StatementsNode (location: (3,18)-(3,19))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (26...27)) │ │ └── @ IntegerNode (location: (3,18)-(3,19))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── opening_loc: (25...26) = "(" │ ├── opening_loc: (3,17)-(3,18) = "("
│ └── closing_loc: (27...28) = ")" │ └── closing_loc: (3,19)-(3,20) = ")"
├── @ ReturnNode (location: (30...39)) ├── @ ReturnNode (location: (5,0)-(5,9))
│ ├── keyword_loc: (30...36) = "return" │ ├── keyword_loc: (5,0)-(5,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (37...39)) │ @ ArgumentsNode (location: (5,7)-(5,9))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ SplatNode (location: (37...39)) │ └── @ SplatNode (location: (5,7)-(5,9))
│ ├── operator_loc: (37...38) = "*" │ ├── operator_loc: (5,7)-(5,8) = "*"
│ └── expression: │ └── expression:
│ @ IntegerNode (location: (38...39)) │ @ IntegerNode (location: (5,8)-(5,9))
│ └── flags: decimal │ └── flags: decimal
├── @ ReturnNode (location: (41...49)) ├── @ ReturnNode (location: (7,0)-(7,8))
│ ├── keyword_loc: (41...47) = "return" │ ├── keyword_loc: (7,0)-(7,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (48...49)) │ @ ArgumentsNode (location: (7,7)-(7,8))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (48...49)) │ └── @ IntegerNode (location: (7,7)-(7,8))
│ └── flags: decimal │ └── flags: decimal
├── @ ReturnNode (location: (51...65)) ├── @ ReturnNode (location: (9,0)-(10,1))
│ ├── keyword_loc: (51...57) = "return" │ ├── keyword_loc: (9,0)-(9,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (58...65)) │ @ ArgumentsNode (location: (9,7)-(10,1))
│ └── arguments: (length: 3) │ └── arguments: (length: 3)
│ ├── @ IntegerNode (location: (58...59)) │ ├── @ IntegerNode (location: (9,7)-(9,8))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── @ IntegerNode (location: (61...62)) │ ├── @ IntegerNode (location: (9,10)-(9,11))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── @ IntegerNode (location: (64...65)) │ └── @ IntegerNode (location: (10,0)-(10,1))
│ └── flags: decimal │ └── flags: decimal
├── @ ReturnNode (location: (67...81)) ├── @ ReturnNode (location: (12,0)-(12,14))
│ ├── keyword_loc: (67...73) = "return" │ ├── keyword_loc: (12,0)-(12,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (74...81)) │ @ ArgumentsNode (location: (12,7)-(12,14))
│ └── arguments: (length: 3) │ └── arguments: (length: 3)
│ ├── @ IntegerNode (location: (74...75)) │ ├── @ IntegerNode (location: (12,7)-(12,8))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── @ IntegerNode (location: (77...78)) │ ├── @ IntegerNode (location: (12,10)-(12,11))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── @ IntegerNode (location: (80...81)) │ └── @ IntegerNode (location: (12,13)-(12,14))
│ └── flags: decimal │ └── flags: decimal
├── @ ReturnNode (location: (83...99)) ├── @ ReturnNode (location: (14,0)-(14,16))
│ ├── keyword_loc: (83...89) = "return" │ ├── keyword_loc: (14,0)-(14,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (90...99)) │ @ ArgumentsNode (location: (14,7)-(14,16))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ ArrayNode (location: (90...99)) │ └── @ ArrayNode (location: (14,7)-(14,16))
│ ├── elements: (length: 3) │ ├── elements: (length: 3)
│ │ ├── @ IntegerNode (location: (91...92)) │ │ ├── @ IntegerNode (location: (14,8)-(14,9))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (94...95)) │ │ ├── @ IntegerNode (location: (14,11)-(14,12))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (97...98)) │ │ └── @ IntegerNode (location: (14,14)-(14,15))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── opening_loc: (90...91) = "[" │ ├── opening_loc: (14,7)-(14,8) = "["
│ └── closing_loc: (98...99) = "]" │ └── closing_loc: (14,15)-(14,16) = "]"
├── @ ReturnNode (location: (101...118)) ├── @ ReturnNode (location: (16,0)-(19,1))
│ ├── keyword_loc: (101...107) = "return" │ ├── keyword_loc: (16,0)-(16,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (107...118)) │ @ ArgumentsNode (location: (16,6)-(19,1))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (107...118)) │ └── @ ParenthesesNode (location: (16,6)-(19,1))
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (111...116)) │ │ @ StatementsNode (location: (17,2)-(18,3))
│ │ └── body: (length: 2) │ │ └── body: (length: 2)
│ │ ├── @ IntegerNode (location: (111...112)) │ │ ├── @ IntegerNode (location: (17,2)-(17,3))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (115...116)) │ │ └── @ IntegerNode (location: (18,2)-(18,3))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── opening_loc: (107...108) = "(" │ ├── opening_loc: (16,6)-(16,7) = "("
│ └── closing_loc: (117...118) = ")" │ └── closing_loc: (19,0)-(19,1) = ")"
├── @ ReturnNode (location: (120...128)) ├── @ ReturnNode (location: (21,0)-(21,8))
│ ├── keyword_loc: (120...126) = "return" │ ├── keyword_loc: (21,0)-(21,6) = "return"
│ └── arguments: │ └── arguments:
│ @ ArgumentsNode (location: (126...128)) │ @ ArgumentsNode (location: (21,6)-(21,8))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (126...128)) │ └── @ ParenthesesNode (location: (21,6)-(21,8))
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (126...127) = "(" │ ├── opening_loc: (21,6)-(21,7) = "("
│ └── closing_loc: (127...128) = ")" │ └── closing_loc: (21,7)-(21,8) = ")"
└── @ ReturnNode (location: (130...139)) └── @ ReturnNode (location: (23,0)-(23,9))
├── keyword_loc: (130...136) = "return" ├── keyword_loc: (23,0)-(23,6) = "return"
└── arguments: └── arguments:
@ ArgumentsNode (location: (136...139)) @ ArgumentsNode (location: (23,6)-(23,9))
└── arguments: (length: 1) └── arguments: (length: 1)
└── @ ParenthesesNode (location: (136...139)) └── @ ParenthesesNode (location: (23,6)-(23,9))
├── body: ├── body:
│ @ StatementsNode (location: (137...138)) │ @ StatementsNode (location: (23,7)-(23,8))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ IntegerNode (location: (137...138)) │ └── @ IntegerNode (location: (23,7)-(23,8))
│ └── flags: decimal │ └── flags: decimal
├── opening_loc: (136...137) = "(" ├── opening_loc: (23,6)-(23,7) = "("
└── closing_loc: (138...139) = ")" └── closing_loc: (23,8)-(23,9) = ")"

16
test/yarp/snapshots/seattlerb/BEGIN.txt
View file

@ -1,14 +1,14 @@
@ ProgramNode (location: (0...12)) @ ProgramNode (location: (1,0)-(1,12))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...12)) @ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1) └── body: (length: 1)
└── @ PreExecutionNode (location: (0...12)) └── @ PreExecutionNode (location: (1,0)-(1,12))
├── statements: ├── statements:
│ @ StatementsNode (location: (8...10)) │ @ StatementsNode (location: (1,8)-(1,10))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ IntegerNode (location: (8...10)) │ └── @ IntegerNode (location: (1,8)-(1,10))
│ └── flags: decimal │ └── flags: decimal
├── keyword_loc: (0...5) = "BEGIN" ├── keyword_loc: (1,0)-(1,5) = "BEGIN"
├── opening_loc: (6...7) = "{" ├── opening_loc: (1,6)-(1,7) = "{"
└── closing_loc: (11...12) = "}" └── closing_loc: (1,11)-(1,12) = "}"

306
test/yarp/snapshots/seattlerb/TestRubyParserShared.txt
View file

@ -1,126 +1,126 @@
@ ProgramNode (location: (0...689)) @ ProgramNode (location: (1,0)-(92,1))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...689)) @ StatementsNode (location: (1,0)-(92,1))
└── body: (length: 16) └── body: (length: 16)
├── @ ArrayNode (location: (0...7)) ├── @ ArrayNode (location: (1,0)-(4,1))
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ ├── opening_loc: (0...3) = "%I[" │ ├── opening_loc: (1,0)-(1,3) = "%I["
│ └── closing_loc: (6...7) = "]" │ └── closing_loc: (4,0)-(4,1) = "]"
├── @ ArrayNode (location: (9...26)) ├── @ ArrayNode (location: (6,0)-(9,1))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (13...18)) │ │ ├── @ SymbolNode (location: (7,0)-(7,5))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (13...18) = "line2" │ │ │ ├── value_loc: (7,0)-(7,5) = "line2"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2" │ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (19...24)) │ │ └── @ SymbolNode (location: (8,0)-(8,5))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (19...24) = "line3" │ │ ├── value_loc: (8,0)-(8,5) = "line3"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3" │ │ └── unescaped: "line3"
│ ├── opening_loc: (9...12) = "%I[" │ ├── opening_loc: (6,0)-(6,3) = "%I["
│ └── closing_loc: (25...26) = "]" │ └── closing_loc: (9,0)-(9,1) = "]"
├── @ ArrayNode (location: (28...35)) ├── @ ArrayNode (location: (11,0)-(14,1))
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ ├── opening_loc: (28...31) = "%W[" │ ├── opening_loc: (11,0)-(11,3) = "%W["
│ └── closing_loc: (34...35) = "]" │ └── closing_loc: (14,0)-(14,1) = "]"
├── @ ArrayNode (location: (37...54)) ├── @ ArrayNode (location: (16,0)-(19,1))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (41...46)) │ │ ├── @ StringNode (location: (17,0)-(17,5))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (41...46) = "line2" │ │ │ ├── content_loc: (17,0)-(17,5) = "line2"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2" │ │ │ └── unescaped: "line2"
│ │ └── @ StringNode (location: (47...52)) │ │ └── @ StringNode (location: (18,0)-(18,5))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (47...52) = "line3" │ │ ├── content_loc: (18,0)-(18,5) = "line3"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3" │ │ └── unescaped: "line3"
│ ├── opening_loc: (37...40) = "%W[" │ ├── opening_loc: (16,0)-(16,3) = "%W["
│ └── closing_loc: (53...54) = "]" │ └── closing_loc: (19,0)-(19,1) = "]"
├── @ ArrayNode (location: (56...63)) ├── @ ArrayNode (location: (21,0)-(24,1))
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ ├── opening_loc: (56...59) = "%i[" │ ├── opening_loc: (21,0)-(21,3) = "%i["
│ └── closing_loc: (62...63) = "]" │ └── closing_loc: (24,0)-(24,1) = "]"
├── @ ArrayNode (location: (65...82)) ├── @ ArrayNode (location: (26,0)-(29,1))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (69...74)) │ │ ├── @ SymbolNode (location: (27,0)-(27,5))
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (69...74) = "line2" │ │ │ ├── value_loc: (27,0)-(27,5) = "line2"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2" │ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (75...80)) │ │ └── @ SymbolNode (location: (28,0)-(28,5))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (75...80) = "line3" │ │ ├── value_loc: (28,0)-(28,5) = "line3"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3" │ │ └── unescaped: "line3"
│ ├── opening_loc: (65...68) = "%i[" │ ├── opening_loc: (26,0)-(26,3) = "%i["
│ └── closing_loc: (81...82) = "]" │ └── closing_loc: (29,0)-(29,1) = "]"
├── @ RegularExpressionNode (location: (84...91)) ├── @ RegularExpressionNode (location: (31,0)-(34,1))
│ ├── opening_loc: (84...87) = "%r[" │ ├── opening_loc: (31,0)-(31,3) = "%r["
│ ├── content_loc: (87...90) = "\n\n\n" │ ├── content_loc: (31,3)-(33,0) = "\n\n\n"
│ ├── closing_loc: (90...91) = "]" │ ├── closing_loc: (34,0)-(34,1) = "]"
│ ├── unescaped: "\n\n\n" │ ├── unescaped: "\n\n\n"
│ └── flags: ∅ │ └── flags: ∅
├── @ ArrayNode (location: (93...100)) ├── @ ArrayNode (location: (36,0)-(39,1))
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ ├── opening_loc: (93...96) = "%w[" │ ├── opening_loc: (36,0)-(36,3) = "%w["
│ └── closing_loc: (99...100) = "]" │ └── closing_loc: (39,0)-(39,1) = "]"
├── @ ArrayNode (location: (102...119)) ├── @ ArrayNode (location: (41,0)-(44,1))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (106...111)) │ │ ├── @ StringNode (location: (42,0)-(42,5))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (106...111) = "line2" │ │ │ ├── content_loc: (42,0)-(42,5) = "line2"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2" │ │ │ └── unescaped: "line2"
│ │ └── @ StringNode (location: (112...117)) │ │ └── @ StringNode (location: (43,0)-(43,5))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── content_loc: (112...117) = "line3" │ │ ├── content_loc: (43,0)-(43,5) = "line3"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3" │ │ └── unescaped: "line3"
│ ├── opening_loc: (102...105) = "%w[" │ ├── opening_loc: (41,0)-(41,3) = "%w["
│ └── closing_loc: (118...119) = "]" │ └── closing_loc: (44,0)-(44,1) = "]"
├── @ ArrayNode (location: (121...139)) ├── @ ArrayNode (location: (46,0)-(49,1))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (123...129)) │ │ ├── @ SymbolNode (location: (47,0)-(47,6))
│ │ │ ├── opening_loc: (123...124) = ":" │ │ │ ├── opening_loc: (47,0)-(47,1) = ":"
│ │ │ ├── value_loc: (124...129) = "line2" │ │ │ ├── value_loc: (47,1)-(47,6) = "line2"
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2" │ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (131...137)) │ │ └── @ SymbolNode (location: (48,0)-(48,6))
│ │ ├── opening_loc: (131...132) = ":" │ │ ├── opening_loc: (48,0)-(48,1) = ":"
│ │ ├── value_loc: (132...137) = "line3" │ │ ├── value_loc: (48,1)-(48,6) = "line3"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3" │ │ └── unescaped: "line3"
│ ├── opening_loc: (121...122) = "[" │ ├── opening_loc: (46,0)-(46,1) = "["
│ └── closing_loc: (138...139) = "]" │ └── closing_loc: (49,0)-(49,1) = "]"
├── @ ClassNode (location: (141...269)) ├── @ ClassNode (location: (51,0)-(56,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (141...146) = "class" │ ├── class_keyword_loc: (51,0)-(51,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (147...148)) │ │ @ ConstantReadNode (location: (51,6)-(51,7))
│ │ └── name: :X │ │ └── name: :X
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (168...246)) │ │ @ StatementsNode (location: (52,2)-(55,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ DefNode (location: (168...246)) │ │ └── @ DefNode (location: (52,2)-(55,5))
│ │ ├── name: :y │ │ ├── name: :y
│ │ ├── name_loc: (177...178) = "y" │ │ ├── name_loc: (52,11)-(52,12) = "y"
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ SelfNode (location: (172...176)) │ │ │ @ SelfNode (location: (52,6)-(52,10))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (179...200)) │ │ │ @ ParametersNode (location: (52,13)-(53,9))
│ │ │ ├── requireds: (length: 2) │ │ │ ├── requireds: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (179...180)) │ │ │ │ ├── @ RequiredParameterNode (location: (52,13)-(52,14))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (199...200)) │ │ │ │ └── @ RequiredParameterNode (location: (53,8)-(53,9))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -129,20 +129,20 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (220...225)) │ │ │ @ StatementsNode (location: (54,4)-(54,9))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (220...225)) │ │ │ └── @ CallNode (location: (54,4)-(54,9))
│ │ │ ├── receiver: │ │ │ ├── receiver:
│ │ │ │ @ LocalVariableReadNode (location: (220...221)) │ │ │ │ @ LocalVariableReadNode (location: (54,4)-(54,5))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (222...223) = "+" │ │ │ ├── message_loc: (54,6)-(54,7) = "+"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: │ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (224...225)) │ │ │ │ @ ArgumentsNode (location: (54,8)-(54,9))
│ │ │ │ └── arguments: (length: 1) │ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ LocalVariableReadNode (location: (224...225)) │ │ │ │ └── @ LocalVariableReadNode (location: (54,8)-(54,9))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -150,68 +150,68 @@
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "+" │ │ │ └── name: "+"
│ │ ├── locals: [:a, :b] │ │ ├── locals: [:a, :b]
│ │ ├── def_keyword_loc: (168...171) = "def" │ │ ├── def_keyword_loc: (52,2)-(52,5) = "def"
│ │ ├── operator_loc: (176...177) = "." │ │ ├── operator_loc: (52,10)-(52,11) = "."
│ │ ├── lparen_loc: (178...179) = "(" │ │ ├── lparen_loc: (52,12)-(52,13) = "("
│ │ ├── rparen_loc: (200...201) = ")" │ │ ├── rparen_loc: (53,9)-(53,10) = ")"
│ │ ├── equal_loc: ∅ │ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (243...246) = "end" │ │ └── end_keyword_loc: (55,2)-(55,5) = "end"
│ ├── end_keyword_loc: (266...269) = "end" │ ├── end_keyword_loc: (56,0)-(56,3) = "end"
│ └── name: :X │ └── name: :X
├── @ ClassNode (location: (293...376)) ├── @ ClassNode (location: (59,0)-(63,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (293...298) = "class" │ ├── class_keyword_loc: (59,0)-(59,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (299...300)) │ │ @ ConstantReadNode (location: (59,6)-(59,7))
│ │ └── name: :X │ │ └── name: :X
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (315...358)) │ │ @ StatementsNode (location: (60,2)-(62,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ClassNode (location: (315...358)) │ │ └── @ ClassNode (location: (60,2)-(62,5))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── class_keyword_loc: (315...320) = "class" │ │ ├── class_keyword_loc: (60,2)-(60,7) = "class"
│ │ ├── constant_path: │ │ ├── constant_path:
│ │ │ @ ConstantReadNode (location: (321...322)) │ │ │ @ ConstantReadNode (location: (60,8)-(60,9))
│ │ │ └── name: :Y │ │ │ └── name: :Y
│ │ ├── inheritance_operator_loc: ∅ │ │ ├── inheritance_operator_loc: ∅
│ │ ├── superclass: ∅ │ │ ├── superclass: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (337...343)) │ │ │ @ StatementsNode (location: (61,4)-(61,10))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ ConstantWriteNode (location: (337...343)) │ │ │ └── @ ConstantWriteNode (location: (61,4)-(61,10))
│ │ │ ├── name: :Z │ │ │ ├── name: :Z
│ │ │ ├── name_loc: (337...338) = "Z" │ │ │ ├── name_loc: (61,4)-(61,5) = "Z"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (341...343)) │ │ │ │ @ IntegerNode (location: (61,8)-(61,10))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (339...340) = "=" │ │ │ └── operator_loc: (61,6)-(61,7) = "="
│ │ ├── end_keyword_loc: (355...358) = "end" │ │ ├── end_keyword_loc: (62,2)-(62,5) = "end"
│ │ └── name: :Y │ │ └── name: :Y
│ ├── end_keyword_loc: (373...376) = "end" │ ├── end_keyword_loc: (63,0)-(63,3) = "end"
│ └── name: :X │ └── name: :X
├── @ ClassNode (location: (395...498)) ├── @ ClassNode (location: (66,0)-(71,3))
│ ├── locals: [] │ ├── locals: []
│ ├── class_keyword_loc: (395...400) = "class" │ ├── class_keyword_loc: (66,0)-(66,5) = "class"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (401...402)) │ │ @ ConstantReadNode (location: (66,6)-(66,7))
│ │ └── name: :X │ │ └── name: :X
│ ├── inheritance_operator_loc: ∅ │ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅ │ ├── superclass: ∅
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (417...480)) │ │ @ StatementsNode (location: (67,2)-(70,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ DefNode (location: (417...480)) │ │ └── @ DefNode (location: (67,2)-(70,5))
│ │ ├── name: :y │ │ ├── name: :y
│ │ ├── name_loc: (421...422) = "y" │ │ ├── name_loc: (67,6)-(67,7) = "y"
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (423...444)) │ │ │ @ ParametersNode (location: (67,8)-(68,9))
│ │ │ ├── requireds: (length: 2) │ │ │ ├── requireds: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (423...424)) │ │ │ │ ├── @ RequiredParameterNode (location: (67,8)-(67,9))
│ │ │ │ │ └── name: :a │ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (443...444)) │ │ │ │ └── @ RequiredParameterNode (location: (68,8)-(68,9))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -220,20 +220,20 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (459...464)) │ │ │ @ StatementsNode (location: (69,4)-(69,9))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (459...464)) │ │ │ └── @ CallNode (location: (69,4)-(69,9))
│ │ │ ├── receiver: │ │ │ ├── receiver:
│ │ │ │ @ LocalVariableReadNode (location: (459...460)) │ │ │ │ @ LocalVariableReadNode (location: (69,4)-(69,5))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (461...462) = "+" │ │ │ ├── message_loc: (69,6)-(69,7) = "+"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: │ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (463...464)) │ │ │ │ @ ArgumentsNode (location: (69,8)-(69,9))
│ │ │ │ └── arguments: (length: 1) │ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ LocalVariableReadNode (location: (463...464)) │ │ │ │ └── @ LocalVariableReadNode (location: (69,8)-(69,9))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -241,92 +241,92 @@
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ └── name: "+" │ │ │ └── name: "+"
│ │ ├── locals: [:a, :b] │ │ ├── locals: [:a, :b]
│ │ ├── def_keyword_loc: (417...420) = "def" │ │ ├── def_keyword_loc: (67,2)-(67,5) = "def"
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: (422...423) = "(" │ │ ├── lparen_loc: (67,7)-(67,8) = "("
│ │ ├── rparen_loc: (444...445) = ")" │ │ ├── rparen_loc: (68,9)-(68,10) = ")"
│ │ ├── equal_loc: ∅ │ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (477...480) = "end" │ │ └── end_keyword_loc: (70,2)-(70,5) = "end"
│ ├── end_keyword_loc: (495...498) = "end" │ ├── end_keyword_loc: (71,0)-(71,3) = "end"
│ └── name: :X │ └── name: :X
├── @ ModuleNode (location: (517...565)) ├── @ ModuleNode (location: (74,0)-(79,3))
│ ├── locals: [] │ ├── locals: []
│ ├── module_keyword_loc: (517...523) = "module" │ ├── module_keyword_loc: (74,0)-(74,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (524...525)) │ │ @ ConstantReadNode (location: (74,7)-(74,8))
│ │ └── name: :X │ │ └── name: :X
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (528...561)) │ │ @ StatementsNode (location: (75,2)-(78,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ConstantWriteNode (location: (528...561)) │ │ └── @ ConstantWriteNode (location: (75,2)-(78,3))
│ │ ├── name: :X │ │ ├── name: :X
│ │ ├── name_loc: (528...529) = "X" │ │ ├── name_loc: (75,2)-(75,3) = "X"
│ │ ├── value: │ │ ├── value:
│ │ │ @ ArrayNode (location: (532...561)) │ │ │ @ ArrayNode (location: (75,6)-(78,3))
│ │ │ ├── elements: (length: 2) │ │ │ ├── elements: (length: 2)
│ │ │ │ ├── @ SymbolNode (location: (538...544)) │ │ │ │ ├── @ SymbolNode (location: (76,4)-(76,10))
│ │ │ │ │ ├── opening_loc: (538...539) = ":" │ │ │ │ │ ├── opening_loc: (76,4)-(76,5) = ":"
│ │ │ │ │ ├── value_loc: (539...544) = "line3" │ │ │ │ │ ├── value_loc: (76,5)-(76,10) = "line3"
│ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ └── unescaped: "line3" │ │ │ │ │ └── unescaped: "line3"
│ │ │ │ └── @ SymbolNode (location: (550...556)) │ │ │ │ └── @ SymbolNode (location: (77,4)-(77,10))
│ │ │ │ ├── opening_loc: (550...551) = ":" │ │ │ │ ├── opening_loc: (77,4)-(77,5) = ":"
│ │ │ │ ├── value_loc: (551...556) = "line4" │ │ │ │ ├── value_loc: (77,5)-(77,10) = "line4"
│ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "line4" │ │ │ │ └── unescaped: "line4"
│ │ │ ├── opening_loc: (532...533) = "[" │ │ │ ├── opening_loc: (75,6)-(75,7) = "["
│ │ │ └── closing_loc: (560...561) = "]" │ │ │ └── closing_loc: (78,2)-(78,3) = "]"
│ │ └── operator_loc: (530...531) = "=" │ │ └── operator_loc: (75,4)-(75,5) = "="
│ ├── end_keyword_loc: (562...565) = "end" │ ├── end_keyword_loc: (79,0)-(79,3) = "end"
│ └── name: :X │ └── name: :X
├── @ ModuleNode (location: (568...651)) ├── @ ModuleNode (location: (82,0)-(86,3))
│ ├── locals: [] │ ├── locals: []
│ ├── module_keyword_loc: (568...574) = "module" │ ├── module_keyword_loc: (82,0)-(82,6) = "module"
│ ├── constant_path: │ ├── constant_path:
│ │ @ ConstantReadNode (location: (575...576)) │ │ @ ConstantReadNode (location: (82,7)-(82,8))
│ │ └── name: :X │ │ └── name: :X
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (590...633)) │ │ @ StatementsNode (location: (83,2)-(85,5))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ModuleNode (location: (590...633)) │ │ └── @ ModuleNode (location: (83,2)-(85,5))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── module_keyword_loc: (590...596) = "module" │ │ ├── module_keyword_loc: (83,2)-(83,8) = "module"
│ │ ├── constant_path: │ │ ├── constant_path:
│ │ │ @ ConstantReadNode (location: (597...598)) │ │ │ @ ConstantReadNode (location: (83,9)-(83,10))
│ │ │ └── name: :Y │ │ │ └── name: :Y
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (612...618)) │ │ │ @ StatementsNode (location: (84,4)-(84,10))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ ConstantWriteNode (location: (612...618)) │ │ │ └── @ ConstantWriteNode (location: (84,4)-(84,10))
│ │ │ ├── name: :Z │ │ │ ├── name: :Z
│ │ │ ├── name_loc: (612...613) = "Z" │ │ │ ├── name_loc: (84,4)-(84,5) = "Z"
│ │ │ ├── value: │ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (616...618)) │ │ │ │ @ IntegerNode (location: (84,8)-(84,10))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (614...615) = "=" │ │ │ └── operator_loc: (84,6)-(84,7) = "="
│ │ ├── end_keyword_loc: (630...633) = "end" │ │ ├── end_keyword_loc: (85,2)-(85,5) = "end"
│ │ └── name: :Y │ │ └── name: :Y
│ ├── end_keyword_loc: (648...651) = "end" │ ├── end_keyword_loc: (86,0)-(86,3) = "end"
│ └── name: :X │ └── name: :X
└── @ CallNode (location: (670...689)) └── @ CallNode (location: (89,0)-(92,1))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (670...671) = "x" ├── message_loc: (89,0)-(89,1) = "x"
├── opening_loc: (671...672) = "(" ├── opening_loc: (89,1)-(89,2) = "("
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (673...687)) │ @ ArgumentsNode (location: (90,0)-(91,6))
│ └── arguments: (length: 2) │ └── arguments: (length: 2)
│ ├── @ SymbolNode (location: (673...679)) │ ├── @ SymbolNode (location: (90,0)-(90,6))
│ │ ├── opening_loc: (673...674) = ":" │ │ ├── opening_loc: (90,0)-(90,1) = ":"
│ │ ├── value_loc: (674...679) = "line2" │ │ ├── value_loc: (90,1)-(90,6) = "line2"
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ └── unescaped: "line2" │ │ └── unescaped: "line2"
│ └── @ SymbolNode (location: (681...687)) │ └── @ SymbolNode (location: (91,0)-(91,6))
│ ├── opening_loc: (681...682) = ":" │ ├── opening_loc: (91,0)-(91,1) = ":"
│ ├── value_loc: (682...687) = "line3" │ ├── value_loc: (91,1)-(91,6) = "line3"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "line3" │ └── unescaped: "line3"
├── closing_loc: (688...689) = ")" ├── closing_loc: (92,0)-(92,1) = ")"
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅
└── name: "x" └── name: "x"

6
test/yarp/snapshots/seattlerb/__ENCODING__.txt
View file

@ -1,6 +1,6 @@
@ ProgramNode (location: (0...12)) @ ProgramNode (location: (1,0)-(1,12))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...12)) @ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1) └── body: (length: 1)
└── @ SourceEncodingNode (location: (0...12)) └── @ SourceEncodingNode (location: (1,0)-(1,12))

12
test/yarp/snapshots/seattlerb/alias_gvar_backref.txt
View file

@ -1,12 +1,12 @@
@ ProgramNode (location: (0...15)) @ ProgramNode (location: (1,0)-(1,15))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...15)) @ StatementsNode (location: (1,0)-(1,15))
└── body: (length: 1) └── body: (length: 1)
└── @ AliasGlobalVariableNode (location: (0...15)) └── @ AliasGlobalVariableNode (location: (1,0)-(1,15))
├── new_name: ├── new_name:
│ @ GlobalVariableReadNode (location: (6...12)) │ @ GlobalVariableReadNode (location: (1,6)-(1,12))
│ └── name: :$MATCH │ └── name: :$MATCH
├── old_name: ├── old_name:
│ @ BackReferenceReadNode (location: (13...15)) │ @ BackReferenceReadNode (location: (1,13)-(1,15))
└── keyword_loc: (0...5) = "alias" └── keyword_loc: (1,0)-(1,5) = "alias"

16
test/yarp/snapshots/seattlerb/alias_resword.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...12)) @ ProgramNode (location: (1,0)-(1,12))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...12)) @ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1) └── body: (length: 1)
└── @ AliasMethodNode (location: (0...12)) └── @ AliasMethodNode (location: (1,0)-(1,12))
├── new_name: ├── new_name:
│ @ SymbolNode (location: (6...8)) │ @ SymbolNode (location: (1,6)-(1,8))
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── value_loc: (6...8) = "in" │ ├── value_loc: (1,6)-(1,8) = "in"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "in" │ └── unescaped: "in"
├── old_name: ├── old_name:
│ @ SymbolNode (location: (9...12)) │ @ SymbolNode (location: (1,9)-(1,12))
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── value_loc: (9...12) = "out" │ ├── value_loc: (1,9)-(1,12) = "out"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ └── unescaped: "out" │ └── unescaped: "out"
└── keyword_loc: (0...5) = "alias" └── keyword_loc: (1,0)-(1,5) = "alias"

22
test/yarp/snapshots/seattlerb/and_multi.txt
View file

@ -1,26 +1,26 @@
@ ProgramNode (location: (0...27)) @ ProgramNode (location: (1,0)-(3,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...27)) @ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 1) └── body: (length: 1)
└── @ AndNode (location: (0...27)) └── @ AndNode (location: (1,0)-(3,4))
├── left: ├── left:
│ @ AndNode (location: (0...18)) │ @ AndNode (location: (1,0)-(2,9))
│ ├── left: │ ├── left:
│ │ @ TrueNode (location: (0...4)) │ │ @ TrueNode (location: (1,0)-(1,4))
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (9...18)) │ │ @ CallNode (location: (2,0)-(2,9))
│ │ ├── receiver: │ │ ├── receiver:
│ │ │ @ FalseNode (location: (13...18)) │ │ │ @ FalseNode (location: (2,4)-(2,9))
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (9...12) = "not" │ │ ├── message_loc: (2,0)-(2,3) = "not"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "!" │ │ └── name: "!"
│ └── operator_loc: (5...8) = "and" │ └── operator_loc: (1,5)-(1,8) = "and"
├── right: ├── right:
│ @ TrueNode (location: (23...27)) │ @ TrueNode (location: (3,0)-(3,4))
└── operator_loc: (19...22) = "and" └── operator_loc: (2,10)-(2,13) = "and"

20
test/yarp/snapshots/seattlerb/aref_args_assocs.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...8)) @ ProgramNode (location: (1,0)-(1,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...8)) @ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1) └── body: (length: 1)
└── @ ArrayNode (location: (0...8)) └── @ ArrayNode (location: (1,0)-(1,8))
├── elements: (length: 1) ├── elements: (length: 1)
│ └── @ KeywordHashNode (location: (1...7)) │ └── @ KeywordHashNode (location: (1,1)-(1,7))
│ └── elements: (length: 1) │ └── elements: (length: 1)
│ └── @ AssocNode (location: (1...7)) │ └── @ AssocNode (location: (1,1)-(1,7))
│ ├── key: │ ├── key:
│ │ @ IntegerNode (location: (1...2)) │ │ @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── value: │ ├── value:
│ │ @ IntegerNode (location: (6...7)) │ │ @ IntegerNode (location: (1,6)-(1,7))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (3...5) = "=>" │ └── operator_loc: (1,3)-(1,5) = "=>"
├── opening_loc: (0...1) = "[" ├── opening_loc: (1,0)-(1,1) = "["
└── closing_loc: (7...8) = "]" └── closing_loc: (1,7)-(1,8) = "]"

22
test/yarp/snapshots/seattlerb/aref_args_lit_assocs.txt
View file

@ -1,21 +1,21 @@
@ ProgramNode (location: (0...11)) @ ProgramNode (location: (1,0)-(1,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...11)) @ StatementsNode (location: (1,0)-(1,11))
└── body: (length: 1) └── body: (length: 1)
└── @ ArrayNode (location: (0...11)) └── @ ArrayNode (location: (1,0)-(1,11))
├── elements: (length: 2) ├── elements: (length: 2)
│ ├── @ IntegerNode (location: (1...2)) │ ├── @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── @ KeywordHashNode (location: (4...10)) │ └── @ KeywordHashNode (location: (1,4)-(1,10))
│ └── elements: (length: 1) │ └── elements: (length: 1)
│ └── @ AssocNode (location: (4...10)) │ └── @ AssocNode (location: (1,4)-(1,10))
│ ├── key: │ ├── key:
│ │ @ IntegerNode (location: (4...5)) │ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── value: │ ├── value:
│ │ @ IntegerNode (location: (9...10)) │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: (6...8) = "=>" │ └── operator_loc: (1,6)-(1,8) = "=>"
├── opening_loc: (0...1) = "[" ├── opening_loc: (1,0)-(1,1) = "["
└── closing_loc: (10...11) = "]" └── closing_loc: (1,10)-(1,11) = "]"

30
test/yarp/snapshots/seattlerb/args_kw_block.txt
View file

@ -1,36 +1,36 @@
@ ProgramNode (location: (0...20)) @ ProgramNode (location: (1,0)-(1,20))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...20)) @ StatementsNode (location: (1,0)-(1,20))
└── body: (length: 1) └── body: (length: 1)
└── @ DefNode (location: (0...20)) └── @ DefNode (location: (1,0)-(1,20))
├── name: :f ├── name: :f
├── name_loc: (4...5) = "f" ├── name_loc: (1,4)-(1,5) = "f"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ├── parameters:
│ @ ParametersNode (location: (6...14)) │ @ ParametersNode (location: (1,6)-(1,14))
│ ├── requireds: (length: 0) │ ├── requireds: (length: 0)
│ ├── optionals: (length: 0) │ ├── optionals: (length: 0)
│ ├── rest: ∅ │ ├── rest: ∅
│ ├── posts: (length: 0) │ ├── posts: (length: 0)
│ ├── keywords: (length: 1) │ ├── keywords: (length: 1)
│ │ └── @ KeywordParameterNode (location: (6...10)) │ │ └── @ KeywordParameterNode (location: (1,6)-(1,10))
│ │ ├── name: :a │ │ ├── name: :a
│ │ ├── name_loc: (6...8) = "a:" │ │ ├── name_loc: (1,6)-(1,8) = "a:"
│ │ └── value: │ │ └── value:
│ │ @ IntegerNode (location: (9...10)) │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── keyword_rest: ∅ │ ├── keyword_rest: ∅
│ └── block: │ └── block:
│ @ BlockParameterNode (location: (12...14)) │ @ BlockParameterNode (location: (1,12)-(1,14))
│ ├── name: :b │ ├── name: :b
│ ├── name_loc: (13...14) = "b" │ ├── name_loc: (1,13)-(1,14) = "b"
│ └── operator_loc: (12...13) = "&" │ └── operator_loc: (1,12)-(1,13) = "&"
├── body: ∅ ├── body: ∅
├── locals: [:a, :b] ├── locals: [:a, :b]
├── def_keyword_loc: (0...3) = "def" ├── def_keyword_loc: (1,0)-(1,3) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: (5...6) = "(" ├── lparen_loc: (1,5)-(1,6) = "("
├── rparen_loc: (14...15) = ")" ├── rparen_loc: (1,14)-(1,15) = ")"
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (17...20) = "end" └── end_keyword_loc: (1,17)-(1,20) = "end"

28
test/yarp/snapshots/seattlerb/array_line_breaks.txt
View file

@ -1,23 +1,23 @@
@ ProgramNode (location: (0...13)) @ ProgramNode (location: (1,0)-(4,1))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...13)) @ StatementsNode (location: (1,0)-(4,1))
└── body: (length: 2) └── body: (length: 2)
├── @ ArrayNode (location: (0...11)) ├── @ ArrayNode (location: (1,0)-(3,4))
│ ├── elements: (length: 2) │ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (2...5)) │ │ ├── @ StringNode (location: (2,0)-(2,3))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (2...3) = "'" │ │ │ ├── opening_loc: (2,0)-(2,1) = "'"
│ │ │ ├── content_loc: (3...4) = "a" │ │ │ ├── content_loc: (2,1)-(2,2) = "a"
│ │ │ ├── closing_loc: (4...5) = "'" │ │ │ ├── closing_loc: (2,2)-(2,3) = "'"
│ │ │ └── unescaped: "a" │ │ │ └── unescaped: "a"
│ │ └── @ StringNode (location: (7...10)) │ │ └── @ StringNode (location: (3,0)-(3,3))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (7...8) = "'" │ │ ├── opening_loc: (3,0)-(3,1) = "'"
│ │ ├── content_loc: (8...9) = "b" │ │ ├── content_loc: (3,1)-(3,2) = "b"
│ │ ├── closing_loc: (9...10) = "'" │ │ ├── closing_loc: (3,2)-(3,3) = "'"
│ │ └── unescaped: "b" │ │ └── unescaped: "b"
│ ├── opening_loc: (0...1) = "[" │ ├── opening_loc: (1,0)-(1,1) = "["
│ └── closing_loc: (10...11) = "]" │ └── closing_loc: (3,3)-(3,4) = "]"
└── @ IntegerNode (location: (12...13)) └── @ IntegerNode (location: (4,0)-(4,1))
└── flags: decimal └── flags: decimal

28
test/yarp/snapshots/seattlerb/array_lits_trailing_calls.txt
View file

@ -1,30 +1,30 @@
@ ProgramNode (location: (0...12)) @ ProgramNode (location: (1,0)-(3,4))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...12)) @ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 2) └── body: (length: 2)
├── @ CallNode (location: (0...6)) ├── @ CallNode (location: (1,0)-(1,6))
│ ├── receiver: │ ├── receiver:
│ │ @ ArrayNode (location: (0...4)) │ │ @ ArrayNode (location: (1,0)-(1,4))
│ │ ├── elements: (length: 0) │ │ ├── elements: (length: 0)
│ │ ├── opening_loc: (0...3) = "%w[" │ │ ├── opening_loc: (1,0)-(1,3) = "%w["
│ │ └── closing_loc: (3...4) = "]" │ │ └── closing_loc: (1,3)-(1,4) = "]"
│ ├── call_operator_loc: (4...5) = "." │ ├── call_operator_loc: (1,4)-(1,5) = "."
│ ├── message_loc: (5...6) = "b" │ ├── message_loc: (1,5)-(1,6) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "b" │ └── name: "b"
└── @ CallNode (location: (8...12)) └── @ CallNode (location: (3,0)-(3,4))
├── receiver: ├── receiver:
│ @ ArrayNode (location: (8...10)) │ @ ArrayNode (location: (3,0)-(3,2))
│ ├── elements: (length: 0) │ ├── elements: (length: 0)
│ ├── opening_loc: (8...9) = "[" │ ├── opening_loc: (3,0)-(3,1) = "["
│ └── closing_loc: (9...10) = "]" │ └── closing_loc: (3,1)-(3,2) = "]"
├── call_operator_loc: (10...11) = "." ├── call_operator_loc: (3,2)-(3,3) = "."
├── message_loc: (11...12) = "b" ├── message_loc: (3,3)-(3,4) = "b"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

24
test/yarp/snapshots/seattlerb/assoc__bare.txt
View file

@ -1,25 +1,25 @@
@ ProgramNode (location: (0...6)) @ ProgramNode (location: (1,0)-(1,6))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...6)) @ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1) └── body: (length: 1)
└── @ HashNode (location: (0...6)) └── @ HashNode (location: (1,0)-(1,6))
├── opening_loc: (0...1) = "{" ├── opening_loc: (1,0)-(1,1) = "{"
├── elements: (length: 1) ├── elements: (length: 1)
│ └── @ AssocNode (location: (2...4)) │ └── @ AssocNode (location: (1,2)-(1,4))
│ ├── key: │ ├── key:
│ │ @ SymbolNode (location: (2...4)) │ │ @ SymbolNode (location: (1,2)-(1,4))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (2...3) = "y" │ │ ├── value_loc: (1,2)-(1,3) = "y"
│ │ ├── closing_loc: (3...4) = ":" │ │ ├── closing_loc: (1,3)-(1,4) = ":"
│ │ └── unescaped: "y" │ │ └── unescaped: "y"
│ ├── value: │ ├── value:
│ │ @ ImplicitNode (location: (2...4)) │ │ @ ImplicitNode (location: (1,2)-(1,4))
│ │ └── value: │ │ └── value:
│ │ @ CallNode (location: (2...4)) │ │ @ CallNode (location: (1,2)-(1,4))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (2...3) = "y" │ │ ├── message_loc: (1,2)-(1,3) = "y"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -27,4 +27,4 @@
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "y" │ │ └── name: "y"
│ └── operator_loc: ∅ │ └── operator_loc: ∅
└── closing_loc: (5...6) = "}" └── closing_loc: (1,5)-(1,6) = "}"

26
test/yarp/snapshots/seattlerb/assoc_label.txt
View file

@ -1,30 +1,30 @@
@ ProgramNode (location: (0...6)) @ ProgramNode (location: (1,0)-(1,6))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...6)) @ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...6)) └── @ CallNode (location: (1,0)-(1,6))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: (1...2) = "(" ├── opening_loc: (1,1)-(1,2) = "("
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (2...5)) │ @ ArgumentsNode (location: (1,2)-(1,5))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ KeywordHashNode (location: (2...5)) │ └── @ KeywordHashNode (location: (1,2)-(1,5))
│ └── elements: (length: 1) │ └── elements: (length: 1)
│ └── @ AssocNode (location: (2...5)) │ └── @ AssocNode (location: (1,2)-(1,5))
│ ├── key: │ ├── key:
│ │ @ SymbolNode (location: (2...4)) │ │ @ SymbolNode (location: (1,2)-(1,4))
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── value_loc: (2...3) = "b" │ │ ├── value_loc: (1,2)-(1,3) = "b"
│ │ ├── closing_loc: (3...4) = ":" │ │ ├── closing_loc: (1,3)-(1,4) = ":"
│ │ └── unescaped: "b" │ │ └── unescaped: "b"
│ ├── value: │ ├── value:
│ │ @ IntegerNode (location: (4...5)) │ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── operator_loc: ∅ │ └── operator_loc: ∅
├── closing_loc: (5...6) = ")" ├── closing_loc: (1,5)-(1,6) = ")"
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

16
test/yarp/snapshots/seattlerb/attr_asgn_colon_id.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...8)) @ ProgramNode (location: (1,0)-(1,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...8)) @ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...8)) └── @ CallNode (location: (1,0)-(1,8))
├── receiver: ├── receiver:
│ @ ConstantReadNode (location: (0...1)) │ @ ConstantReadNode (location: (1,0)-(1,1))
│ └── name: :A │ └── name: :A
├── call_operator_loc: (1...3) = "::" ├── call_operator_loc: (1,1)-(1,3) = "::"
├── message_loc: (3...4) = "b" ├── message_loc: (1,3)-(1,4) = "b"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (7...8)) │ @ ArgumentsNode (location: (1,7)-(1,8))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (7...8)) │ └── @ IntegerNode (location: (1,7)-(1,8))
│ └── flags: decimal │ └── flags: decimal
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅

30
test/yarp/snapshots/seattlerb/attrasgn_array_arg.txt
View file

@ -1,14 +1,14 @@
@ ProgramNode (location: (0...13)) @ ProgramNode (location: (1,0)-(1,13))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...13)) @ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...13)) └── @ CallNode (location: (1,0)-(1,13))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...1)) │ @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a" │ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
@ -16,22 +16,22 @@
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "a" │ └── name: "a"
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (1...9) = "[[1, 2]]" ├── message_loc: (1,1)-(1,9) = "[[1, 2]]"
├── opening_loc: (1...2) = "[" ├── opening_loc: (1,1)-(1,2) = "["
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (2...13)) │ @ ArgumentsNode (location: (1,2)-(1,13))
│ └── arguments: (length: 2) │ └── arguments: (length: 2)
│ ├── @ ArrayNode (location: (2...8)) │ ├── @ ArrayNode (location: (1,2)-(1,8))
│ │ ├── elements: (length: 2) │ │ ├── elements: (length: 2)
│ │ │ ├── @ IntegerNode (location: (3...4)) │ │ │ ├── @ IntegerNode (location: (1,3)-(1,4))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (6...7)) │ │ │ └── @ IntegerNode (location: (1,6)-(1,7))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── opening_loc: (2...3) = "[" │ │ ├── opening_loc: (1,2)-(1,3) = "["
│ │ └── closing_loc: (7...8) = "]" │ │ └── closing_loc: (1,7)-(1,8) = "]"
│ └── @ IntegerNode (location: (12...13)) │ └── @ IntegerNode (location: (1,12)-(1,13))
│ └── flags: decimal │ └── flags: decimal
├── closing_loc: (8...9) = "]" ├── closing_loc: (1,8)-(1,9) = "]"
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅
└── name: "[]=" └── name: "[]="

70
test/yarp/snapshots/seattlerb/attrasgn_array_lhs.txt
View file

@ -1,34 +1,34 @@
@ ProgramNode (location: (0...42)) @ ProgramNode (location: (1,0)-(1,42))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...42)) @ StatementsNode (location: (1,0)-(1,42))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...42)) └── @ CallNode (location: (1,0)-(1,42))
├── receiver: ├── receiver:
│ @ ArrayNode (location: (0...12)) │ @ ArrayNode (location: (1,0)-(1,12))
│ ├── elements: (length: 4) │ ├── elements: (length: 4)
│ │ ├── @ IntegerNode (location: (1...2)) │ │ ├── @ IntegerNode (location: (1,1)-(1,2))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (4...5)) │ │ ├── @ IntegerNode (location: (1,4)-(1,5))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (7...8)) │ │ ├── @ IntegerNode (location: (1,7)-(1,8))
│ │ │ └── flags: decimal │ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (10...11)) │ │ └── @ IntegerNode (location: (1,10)-(1,11))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── opening_loc: (0...1) = "[" │ ├── opening_loc: (1,0)-(1,1) = "["
│ └── closing_loc: (11...12) = "]" │ └── closing_loc: (1,11)-(1,12) = "]"
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (12...24) = "[from .. to]" ├── message_loc: (1,12)-(1,24) = "[from .. to]"
├── opening_loc: (12...13) = "[" ├── opening_loc: (1,12)-(1,13) = "["
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (13...42)) │ @ ArgumentsNode (location: (1,13)-(1,42))
│ └── arguments: (length: 2) │ └── arguments: (length: 2)
│ ├── @ RangeNode (location: (13...23)) │ ├── @ RangeNode (location: (1,13)-(1,23))
│ │ ├── left: │ │ ├── left:
│ │ │ @ CallNode (location: (13...17)) │ │ │ @ CallNode (location: (1,13)-(1,17))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (13...17) = "from" │ │ │ ├── message_loc: (1,13)-(1,17) = "from"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -36,41 +36,41 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "from" │ │ │ └── name: "from"
│ │ ├── right: │ │ ├── right:
│ │ │ @ CallNode (location: (21...23)) │ │ │ @ CallNode (location: (1,21)-(1,23))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (21...23) = "to" │ │ │ ├── message_loc: (1,21)-(1,23) = "to"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "to" │ │ │ └── name: "to"
│ │ ├── operator_loc: (18...20) = ".." │ │ ├── operator_loc: (1,18)-(1,20) = ".."
│ │ └── flags: ∅ │ │ └── flags: ∅
│ └── @ ArrayNode (location: (27...42)) │ └── @ ArrayNode (location: (1,27)-(1,42))
│ ├── elements: (length: 3) │ ├── elements: (length: 3)
│ │ ├── @ StringNode (location: (28...31)) │ │ ├── @ StringNode (location: (1,28)-(1,31))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (28...29) = "\"" │ │ │ ├── opening_loc: (1,28)-(1,29) = "\""
│ │ │ ├── content_loc: (29...30) = "a" │ │ │ ├── content_loc: (1,29)-(1,30) = "a"
│ │ │ ├── closing_loc: (30...31) = "\"" │ │ │ ├── closing_loc: (1,30)-(1,31) = "\""
│ │ │ └── unescaped: "a" │ │ │ └── unescaped: "a"
│ │ ├── @ StringNode (location: (33...36)) │ │ ├── @ StringNode (location: (1,33)-(1,36))
│ │ │ ├── flags: ∅ │ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (33...34) = "\"" │ │ │ ├── opening_loc: (1,33)-(1,34) = "\""
│ │ │ ├── content_loc: (34...35) = "b" │ │ │ ├── content_loc: (1,34)-(1,35) = "b"
│ │ │ ├── closing_loc: (35...36) = "\"" │ │ │ ├── closing_loc: (1,35)-(1,36) = "\""
│ │ │ └── unescaped: "b" │ │ │ └── unescaped: "b"
│ │ └── @ StringNode (location: (38...41)) │ │ └── @ StringNode (location: (1,38)-(1,41))
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ ├── opening_loc: (38...39) = "\"" │ │ ├── opening_loc: (1,38)-(1,39) = "\""
│ │ ├── content_loc: (39...40) = "c" │ │ ├── content_loc: (1,39)-(1,40) = "c"
│ │ ├── closing_loc: (40...41) = "\"" │ │ ├── closing_loc: (1,40)-(1,41) = "\""
│ │ └── unescaped: "c" │ │ └── unescaped: "c"
│ ├── opening_loc: (27...28) = "[" │ ├── opening_loc: (1,27)-(1,28) = "["
│ └── closing_loc: (41...42) = "]" │ └── closing_loc: (1,41)-(1,42) = "]"
├── closing_loc: (23...24) = "]" ├── closing_loc: (1,23)-(1,24) = "]"
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅
└── name: "[]=" └── name: "[]="

18
test/yarp/snapshots/seattlerb/attrasgn_primary_dot_constant.txt
View file

@ -1,27 +1,27 @@
@ ProgramNode (location: (0...7)) @ ProgramNode (location: (1,0)-(1,7))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...7)) @ StatementsNode (location: (1,0)-(1,7))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...7)) └── @ CallNode (location: (1,0)-(1,7))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...1)) │ @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a" │ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "a" │ └── name: "a"
├── call_operator_loc: (1...2) = "." ├── call_operator_loc: (1,1)-(1,2) = "."
├── message_loc: (2...3) = "B" ├── message_loc: (1,2)-(1,3) = "B"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (6...7)) │ @ ArgumentsNode (location: (1,6)-(1,7))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (6...7)) │ └── @ IntegerNode (location: (1,6)-(1,7))
│ └── flags: decimal │ └── flags: decimal
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅

28
test/yarp/snapshots/seattlerb/backticks_interpolation_line.txt
View file

@ -1,36 +1,36 @@
@ ProgramNode (location: (0...8)) @ ProgramNode (location: (1,0)-(1,8))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...8)) @ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...8)) └── @ CallNode (location: (1,0)-(1,8))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "x" ├── message_loc: (1,0)-(1,1) = "x"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (2...8)) │ @ ArgumentsNode (location: (1,2)-(1,8))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ InterpolatedXStringNode (location: (2...8)) │ └── @ InterpolatedXStringNode (location: (1,2)-(1,8))
│ ├── opening_loc: (2...3) = "`" │ ├── opening_loc: (1,2)-(1,3) = "`"
│ ├── parts: (length: 1) │ ├── parts: (length: 1)
│ │ └── @ EmbeddedStatementsNode (location: (3...7)) │ │ └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
│ │ ├── opening_loc: (3...5) = "\#{" │ │ ├── opening_loc: (1,3)-(1,5) = "\#{"
│ │ ├── statements: │ │ ├── statements:
│ │ │ @ StatementsNode (location: (5...6)) │ │ │ @ StatementsNode (location: (1,5)-(1,6))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (5...6)) │ │ │ └── @ CallNode (location: (1,5)-(1,6))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (5...6) = "y" │ │ │ ├── message_loc: (1,5)-(1,6) = "y"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "y" │ │ │ └── name: "y"
│ │ └── closing_loc: (6...7) = "}" │ │ └── closing_loc: (1,6)-(1,7) = "}"
│ └── closing_loc: (7...8) = "`" │ └── closing_loc: (1,7)-(1,8) = "`"
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅
├── flags: ∅ ├── flags: ∅

14
test/yarp/snapshots/seattlerb/bang_eq.txt
View file

@ -1,19 +1,19 @@
@ ProgramNode (location: (0...6)) @ ProgramNode (location: (1,0)-(1,6))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...6)) @ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...6)) └── @ CallNode (location: (1,0)-(1,6))
├── receiver: ├── receiver:
│ @ IntegerNode (location: (0...1)) │ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal │ └── flags: decimal
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (2...4) = "!=" ├── message_loc: (1,2)-(1,4) = "!="
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (5...6)) │ @ ArgumentsNode (location: (1,5)-(1,6))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (5...6)) │ └── @ IntegerNode (location: (1,5)-(1,6))
│ └── flags: decimal │ └── flags: decimal
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ∅ ├── block: ∅

22
test/yarp/snapshots/seattlerb/bdot2.txt
View file

@ -1,34 +1,34 @@
@ ProgramNode (location: (0...14)) @ ProgramNode (location: (1,0)-(3,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...14)) @ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 3) └── body: (length: 3)
├── @ RangeNode (location: (0...4)) ├── @ RangeNode (location: (1,0)-(1,4))
│ ├── left: ∅ │ ├── left: ∅
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (2...4)) │ │ @ IntegerNode (location: (1,2)-(1,4))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── operator_loc: (0...2) = ".." │ ├── operator_loc: (1,0)-(1,2) = ".."
│ └── flags: ∅ │ └── flags: ∅
├── @ RangeNode (location: (7...10)) ├── @ RangeNode (location: (2,2)-(2,5))
│ ├── left: ∅ │ ├── left: ∅
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (9...10)) │ │ @ CallNode (location: (2,4)-(2,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (9...10) = "a" │ │ ├── message_loc: (2,4)-(2,5) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── operator_loc: (7...9) = ".." │ ├── operator_loc: (2,2)-(2,4) = ".."
│ └── flags: ∅ │ └── flags: ∅
└── @ CallNode (location: (13...14)) └── @ CallNode (location: (3,2)-(3,3))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (13...14) = "c" ├── message_loc: (3,2)-(3,3) = "c"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

22
test/yarp/snapshots/seattlerb/bdot3.txt
View file

@ -1,34 +1,34 @@
@ ProgramNode (location: (0...16)) @ ProgramNode (location: (1,0)-(3,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...16)) @ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 3) └── body: (length: 3)
├── @ RangeNode (location: (0...5)) ├── @ RangeNode (location: (1,0)-(1,5))
│ ├── left: ∅ │ ├── left: ∅
│ ├── right: │ ├── right:
│ │ @ IntegerNode (location: (3...5)) │ │ @ IntegerNode (location: (1,3)-(1,5))
│ │ └── flags: decimal │ │ └── flags: decimal
│ ├── operator_loc: (0...3) = "..." │ ├── operator_loc: (1,0)-(1,3) = "..."
│ └── flags: exclude_end │ └── flags: exclude_end
├── @ RangeNode (location: (8...12)) ├── @ RangeNode (location: (2,2)-(2,6))
│ ├── left: ∅ │ ├── left: ∅
│ ├── right: │ ├── right:
│ │ @ CallNode (location: (11...12)) │ │ @ CallNode (location: (2,5)-(2,6))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (11...12) = "a" │ │ ├── message_loc: (2,5)-(2,6) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── operator_loc: (8...11) = "..." │ ├── operator_loc: (2,2)-(2,5) = "..."
│ └── flags: exclude_end │ └── flags: exclude_end
└── @ CallNode (location: (15...16)) └── @ CallNode (location: (3,2)-(3,3))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (15...16) = "c" ├── message_loc: (3,2)-(3,3) = "c"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

16
test/yarp/snapshots/seattlerb/begin_ensure_no_bodies.txt
View file

@ -1,16 +1,16 @@
@ ProgramNode (location: (0...16)) @ ProgramNode (location: (1,0)-(3,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...16)) @ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 1) └── body: (length: 1)
└── @ BeginNode (location: (0...16)) └── @ BeginNode (location: (1,0)-(3,3))
├── begin_keyword_loc: (0...5) = "begin" ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅ ├── statements: ∅
├── rescue_clause: ∅ ├── rescue_clause: ∅
├── else_clause: ∅ ├── else_clause: ∅
├── ensure_clause: ├── ensure_clause:
│ @ EnsureNode (location: (6...16)) │ @ EnsureNode (location: (2,0)-(3,3))
│ ├── ensure_keyword_loc: (6...12) = "ensure" │ ├── ensure_keyword_loc: (2,0)-(2,6) = "ensure"
│ ├── statements: ∅ │ ├── statements: ∅
│ └── end_keyword_loc: (13...16) = "end" │ └── end_keyword_loc: (3,0)-(3,3) = "end"
└── end_keyword_loc: (13...16) = "end" └── end_keyword_loc: (3,0)-(3,3) = "end"

42
test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_bodies.txt
View file

@ -1,43 +1,43 @@
@ ProgramNode (location: (0...44)) @ ProgramNode (location: (1,0)-(9,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...44)) @ StatementsNode (location: (1,0)-(9,3))
└── body: (length: 1) └── body: (length: 1)
└── @ BeginNode (location: (0...44)) └── @ BeginNode (location: (1,0)-(9,3))
├── begin_keyword_loc: (0...5) = "begin" ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ├── statements:
│ @ StatementsNode (location: (8...9)) │ @ StatementsNode (location: (2,2)-(2,3))
│ └── body: (length: 1) │ └── body: (length: 1)
│ └── @ IntegerNode (location: (8...9)) │ └── @ IntegerNode (location: (2,2)-(2,3))
│ └── flags: decimal │ └── flags: decimal
├── rescue_clause: ├── rescue_clause:
│ @ RescueNode (location: (10...20)) │ @ RescueNode (location: (3,0)-(4,3))
│ ├── keyword_loc: (10...16) = "rescue" │ ├── keyword_loc: (3,0)-(3,6) = "rescue"
│ ├── exceptions: (length: 0) │ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── reference: ∅ │ ├── reference: ∅
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (19...20)) │ │ @ StatementsNode (location: (4,2)-(4,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (19...20)) │ │ └── @ IntegerNode (location: (4,2)-(4,3))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── consequent: ∅ │ └── consequent: ∅
├── else_clause: ├── else_clause:
│ @ ElseNode (location: (21...36)) │ @ ElseNode (location: (5,0)-(7,6))
│ ├── else_keyword_loc: (21...25) = "else" │ ├── else_keyword_loc: (5,0)-(5,4) = "else"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (28...29)) │ │ @ StatementsNode (location: (6,2)-(6,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (28...29)) │ │ └── @ IntegerNode (location: (6,2)-(6,3))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── end_keyword_loc: (30...36) = "ensure" │ └── end_keyword_loc: (7,0)-(7,6) = "ensure"
├── ensure_clause: ├── ensure_clause:
│ @ EnsureNode (location: (30...44)) │ @ EnsureNode (location: (7,0)-(9,3))
│ ├── ensure_keyword_loc: (30...36) = "ensure" │ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
│ ├── statements: │ ├── statements:
│ │ @ StatementsNode (location: (39...40)) │ │ @ StatementsNode (location: (8,2)-(8,3))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (39...40)) │ │ └── @ IntegerNode (location: (8,2)-(8,3))
│ │ └── flags: decimal │ │ └── flags: decimal
│ └── end_keyword_loc: (41...44) = "end" │ └── end_keyword_loc: (9,0)-(9,3) = "end"
└── end_keyword_loc: (41...44) = "end" └── end_keyword_loc: (9,0)-(9,3) = "end"

26
test/yarp/snapshots/seattlerb/begin_rescue_else_ensure_no_bodies.txt
View file

@ -1,27 +1,27 @@
@ ProgramNode (location: (0...32)) @ ProgramNode (location: (1,0)-(9,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...32)) @ StatementsNode (location: (1,0)-(9,3))
└── body: (length: 1) └── body: (length: 1)
└── @ BeginNode (location: (0...32)) └── @ BeginNode (location: (1,0)-(9,3))
├── begin_keyword_loc: (0...5) = "begin" ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅ ├── statements: ∅
├── rescue_clause: ├── rescue_clause:
│ @ RescueNode (location: (7...13)) │ @ RescueNode (location: (3,0)-(3,6))
│ ├── keyword_loc: (7...13) = "rescue" │ ├── keyword_loc: (3,0)-(3,6) = "rescue"
│ ├── exceptions: (length: 0) │ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── reference: ∅ │ ├── reference: ∅
│ ├── statements: ∅ │ ├── statements: ∅
│ └── consequent: ∅ │ └── consequent: ∅
├── else_clause: ├── else_clause:
│ @ ElseNode (location: (15...27)) │ @ ElseNode (location: (5,0)-(7,6))
│ ├── else_keyword_loc: (15...19) = "else" │ ├── else_keyword_loc: (5,0)-(5,4) = "else"
│ ├── statements: ∅ │ ├── statements: ∅
│ └── end_keyword_loc: (21...27) = "ensure" │ └── end_keyword_loc: (7,0)-(7,6) = "ensure"
├── ensure_clause: ├── ensure_clause:
│ @ EnsureNode (location: (21...32)) │ @ EnsureNode (location: (7,0)-(9,3))
│ ├── ensure_keyword_loc: (21...27) = "ensure" │ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
│ ├── statements: ∅ │ ├── statements: ∅
│ └── end_keyword_loc: (29...32) = "end" │ └── end_keyword_loc: (9,0)-(9,3) = "end"
└── end_keyword_loc: (29...32) = "end" └── end_keyword_loc: (9,0)-(9,3) = "end"

20
test/yarp/snapshots/seattlerb/begin_rescue_ensure_no_bodies.txt
View file

@ -1,14 +1,14 @@
@ ProgramNode (location: (0...23)) @ ProgramNode (location: (1,0)-(4,3))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...23)) @ StatementsNode (location: (1,0)-(4,3))
└── body: (length: 1) └── body: (length: 1)
└── @ BeginNode (location: (0...23)) └── @ BeginNode (location: (1,0)-(4,3))
├── begin_keyword_loc: (0...5) = "begin" ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅ ├── statements: ∅
├── rescue_clause: ├── rescue_clause:
│ @ RescueNode (location: (6...12)) │ @ RescueNode (location: (2,0)-(2,6))
│ ├── keyword_loc: (6...12) = "rescue" │ ├── keyword_loc: (2,0)-(2,6) = "rescue"
│ ├── exceptions: (length: 0) │ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅ │ ├── operator_loc: ∅
│ ├── reference: ∅ │ ├── reference: ∅
@ -16,8 +16,8 @@
│ └── consequent: ∅ │ └── consequent: ∅
├── else_clause: ∅ ├── else_clause: ∅
├── ensure_clause: ├── ensure_clause:
│ @ EnsureNode (location: (13...23)) │ @ EnsureNode (location: (3,0)-(4,3))
│ ├── ensure_keyword_loc: (13...19) = "ensure" │ ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
│ ├── statements: ∅ │ ├── statements: ∅
│ └── end_keyword_loc: (20...23) = "end" │ └── end_keyword_loc: (4,0)-(4,3) = "end"
└── end_keyword_loc: (20...23) = "end" └── end_keyword_loc: (4,0)-(4,3) = "end"

22
test/yarp/snapshots/seattlerb/block_arg__bare.txt
View file

@ -1,14 +1,14 @@
@ ProgramNode (location: (0...13)) @ ProgramNode (location: (1,0)-(1,13))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...13)) @ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1) └── body: (length: 1)
└── @ DefNode (location: (0...13)) └── @ DefNode (location: (1,0)-(1,13))
├── name: :x ├── name: :x
├── name_loc: (4...5) = "x" ├── name_loc: (1,4)-(1,5) = "x"
├── receiver: ∅ ├── receiver: ∅
├── parameters: ├── parameters:
│ @ ParametersNode (location: (6...7)) │ @ ParametersNode (location: (1,6)-(1,7))
│ ├── requireds: (length: 0) │ ├── requireds: (length: 0)
│ ├── optionals: (length: 0) │ ├── optionals: (length: 0)
│ ├── rest: ∅ │ ├── rest: ∅
@ -16,15 +16,15 @@
│ ├── keywords: (length: 0) │ ├── keywords: (length: 0)
│ ├── keyword_rest: ∅ │ ├── keyword_rest: ∅
│ └── block: │ └── block:
│ @ BlockParameterNode (location: (6...7)) │ @ BlockParameterNode (location: (1,6)-(1,7))
│ ├── name: nil │ ├── name: nil
│ ├── name_loc: ∅ │ ├── name_loc: ∅
│ └── operator_loc: (6...7) = "&" │ └── operator_loc: (1,6)-(1,7) = "&"
├── body: ∅ ├── body: ∅
├── locals: [:&] ├── locals: [:&]
├── def_keyword_loc: (0...3) = "def" ├── def_keyword_loc: (1,0)-(1,3) = "def"
├── operator_loc: ∅ ├── operator_loc: ∅
├── lparen_loc: (5...6) = "(" ├── lparen_loc: (1,5)-(1,6) = "("
├── rparen_loc: (7...8) = ")" ├── rparen_loc: (1,7)-(1,8) = ")"
├── equal_loc: ∅ ├── equal_loc: ∅
└── end_keyword_loc: (10...13) = "end" └── end_keyword_loc: (1,10)-(1,13) = "end"

28
test/yarp/snapshots/seattlerb/block_arg_kwsplat.txt
View file

@ -1,38 +1,38 @@
@ ProgramNode (location: (0...11)) @ ProgramNode (location: (1,0)-(1,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...11)) @ StatementsNode (location: (1,0)-(1,11))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...11)) └── @ CallNode (location: (1,0)-(1,11))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...11)) │ @ BlockNode (location: (1,2)-(1,11))
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...9)) │ │ @ BlockParametersNode (location: (1,4)-(1,9))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...8)) │ │ │ @ ParametersNode (location: (1,5)-(1,8))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: │ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (5...8)) │ │ │ │ @ KeywordRestParameterNode (location: (1,5)-(1,8))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (7...8) = "b" │ │ │ │ ├── name_loc: (1,7)-(1,8) = "b"
│ │ │ │ └── operator_loc: (5...7) = "**" │ │ │ │ └── operator_loc: (1,5)-(1,7) = "**"
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (8...9) = "|" │ │ └── closing_loc: (1,8)-(1,9) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (10...11) = "}" │ └── closing_loc: (1,10)-(1,11) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

40
test/yarp/snapshots/seattlerb/block_arg_opt_arg_block.txt
View file

@ -1,49 +1,49 @@
@ ProgramNode (location: (0...21)) @ ProgramNode (location: (1,0)-(1,21))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...21)) @ StatementsNode (location: (1,0)-(1,21))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...21)) └── @ CallNode (location: (1,0)-(1,21))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...21)) │ @ BlockNode (location: (1,2)-(1,21))
│ ├── locals: [:b, :c, :d, :e] │ ├── locals: [:b, :c, :d, :e]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...19)) │ │ @ BlockParametersNode (location: (1,4)-(1,19))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...18)) │ │ │ @ ParametersNode (location: (1,5)-(1,18))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...11)) │ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,11))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c" │ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (9...10) = "=" │ │ │ │ ├── operator_loc: (1,9)-(1,10) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (10...11)) │ │ │ │ @ IntegerNode (location: (1,10)-(1,11))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 1) │ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (13...14)) │ │ │ │ └── @ RequiredParameterNode (location: (1,13)-(1,14))
│ │ │ │ └── name: :d │ │ │ │ └── name: :d
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (16...18)) │ │ │ @ BlockParameterNode (location: (1,16)-(1,18))
│ │ │ ├── name: :e │ │ │ ├── name: :e
│ │ │ ├── name_loc: (17...18) = "e" │ │ │ ├── name_loc: (1,17)-(1,18) = "e"
│ │ │ └── operator_loc: (16...17) = "&" │ │ │ └── operator_loc: (1,16)-(1,17) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (18...19) = "|" │ │ └── closing_loc: (1,18)-(1,19) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (20...21) = "}" │ └── closing_loc: (1,20)-(1,21) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

38
test/yarp/snapshots/seattlerb/block_arg_opt_splat.txt
View file

@ -1,47 +1,47 @@
@ ProgramNode (location: (0...20)) @ ProgramNode (location: (1,0)-(1,20))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...20)) @ StatementsNode (location: (1,0)-(1,20))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...20)) └── @ CallNode (location: (1,0)-(1,20))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...20)) │ @ BlockNode (location: (1,2)-(1,20))
│ ├── locals: [:b, :c, :d] │ ├── locals: [:b, :c, :d]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...18)) │ │ @ BlockParametersNode (location: (1,4)-(1,18))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...17)) │ │ │ @ ParametersNode (location: (1,5)-(1,17))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...13)) │ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,13))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c" │ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (10...11) = "=" │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (12...13)) │ │ │ │ @ IntegerNode (location: (1,12)-(1,13))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (15...17)) │ │ │ │ @ RestParameterNode (location: (1,15)-(1,17))
│ │ │ │ ├── name: :d │ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (16...17) = "d" │ │ │ │ ├── name_loc: (1,16)-(1,17) = "d"
│ │ │ │ └── operator_loc: (15...16) = "*" │ │ │ │ └── operator_loc: (1,15)-(1,16) = "*"
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (17...18) = "|" │ │ └── closing_loc: (1,17)-(1,18) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (19...20) = "}" │ └── closing_loc: (1,19)-(1,20) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

46
test/yarp/snapshots/seattlerb/block_arg_opt_splat_arg_block_omfg.txt
View file

@ -1,53 +1,53 @@
@ ProgramNode (location: (0...25)) @ ProgramNode (location: (1,0)-(1,25))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...25)) @ StatementsNode (location: (1,0)-(1,25))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...25)) └── @ CallNode (location: (1,0)-(1,25))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...25)) │ @ BlockNode (location: (1,2)-(1,25))
│ ├── locals: [:b, :c, :d, :e, :f] │ ├── locals: [:b, :c, :d, :e, :f]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...23)) │ │ @ BlockParametersNode (location: (1,4)-(1,23))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...22)) │ │ │ @ ParametersNode (location: (1,5)-(1,22))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...11)) │ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,11))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c" │ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (9...10) = "=" │ │ │ │ ├── operator_loc: (1,9)-(1,10) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (10...11)) │ │ │ │ @ IntegerNode (location: (1,10)-(1,11))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (13...15)) │ │ │ │ @ RestParameterNode (location: (1,13)-(1,15))
│ │ │ │ ├── name: :d │ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (14...15) = "d" │ │ │ │ ├── name_loc: (1,14)-(1,15) = "d"
│ │ │ │ └── operator_loc: (13...14) = "*" │ │ │ │ └── operator_loc: (1,13)-(1,14) = "*"
│ │ │ ├── posts: (length: 1) │ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (17...18)) │ │ │ │ └── @ RequiredParameterNode (location: (1,17)-(1,18))
│ │ │ │ └── name: :e │ │ │ │ └── name: :e
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (20...22)) │ │ │ @ BlockParameterNode (location: (1,20)-(1,22))
│ │ │ ├── name: :f │ │ │ ├── name: :f
│ │ │ ├── name_loc: (21...22) = "f" │ │ │ ├── name_loc: (1,21)-(1,22) = "f"
│ │ │ └── operator_loc: (20...21) = "&" │ │ │ └── operator_loc: (1,20)-(1,21) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (22...23) = "|" │ │ └── closing_loc: (1,22)-(1,23) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (24...25) = "}" │ └── closing_loc: (1,24)-(1,25) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

30
test/yarp/snapshots/seattlerb/block_arg_optional.txt
View file

@ -1,30 +1,30 @@
@ ProgramNode (location: (0...13)) @ ProgramNode (location: (1,0)-(1,13))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...13)) @ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...13)) └── @ CallNode (location: (1,0)-(1,13))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...13)) │ @ BlockNode (location: (1,2)-(1,13))
│ ├── locals: [:b] │ ├── locals: [:b]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...11)) │ │ @ BlockParametersNode (location: (1,4)-(1,11))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...10)) │ │ │ @ ParametersNode (location: (1,5)-(1,10))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (5...10)) │ │ │ │ └── @ OptionalParameterNode (location: (1,5)-(1,10))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (5...6) = "b" │ │ │ │ ├── name_loc: (1,5)-(1,6) = "b"
│ │ │ │ ├── operator_loc: (7...8) = "=" │ │ │ │ ├── operator_loc: (1,7)-(1,8) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (9...10)) │ │ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
@ -32,10 +32,10 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (10...11) = "|" │ │ └── closing_loc: (1,10)-(1,11) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (12...13) = "}" │ └── closing_loc: (1,12)-(1,13) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

26
test/yarp/snapshots/seattlerb/block_arg_scope.txt
View file

@ -1,24 +1,24 @@
@ ProgramNode (location: (0...12)) @ ProgramNode (location: (1,0)-(1,12))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...12)) @ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...12)) └── @ CallNode (location: (1,0)-(1,12))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...12)) │ @ BlockNode (location: (1,2)-(1,12))
│ ├── locals: [:b, :c] │ ├── locals: [:b, :c]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...10)) │ │ @ BlockParametersNode (location: (1,4)-(1,10))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...6)) │ │ │ @ ParametersNode (location: (1,5)-(1,6))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -27,12 +27,12 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 1) │ │ ├── locals: (length: 1)
│ │ │ └── @ BlockLocalVariableNode (location: (8...9)) │ │ │ └── @ BlockLocalVariableNode (location: (1,8)-(1,9))
│ │ │ └── name: :c │ │ │ └── name: :c
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (9...10) = "|" │ │ └── closing_loc: (1,9)-(1,10) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (11...12) = "}" │ └── closing_loc: (1,11)-(1,12) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

28
test/yarp/snapshots/seattlerb/block_arg_scope2.txt
View file

@ -1,24 +1,24 @@
@ ProgramNode (location: (0...14)) @ ProgramNode (location: (1,0)-(1,14))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...14)) @ StatementsNode (location: (1,0)-(1,14))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...14)) └── @ CallNode (location: (1,0)-(1,14))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...14)) │ @ BlockNode (location: (1,2)-(1,14))
│ ├── locals: [:b, :c, :d] │ ├── locals: [:b, :c, :d]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (3...12)) │ │ @ BlockParametersNode (location: (1,3)-(1,12))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (4...5)) │ │ │ @ ParametersNode (location: (1,4)-(1,5))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (4...5)) │ │ │ │ └── @ RequiredParameterNode (location: (1,4)-(1,5))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -27,14 +27,14 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 2) │ │ ├── locals: (length: 2)
│ │ │ ├── @ BlockLocalVariableNode (location: (7...8)) │ │ │ ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
│ │ │ │ └── name: :c │ │ │ │ └── name: :c
│ │ │ └── @ BlockLocalVariableNode (location: (10...11)) │ │ │ └── @ BlockLocalVariableNode (location: (1,10)-(1,11))
│ │ │ └── name: :d │ │ │ └── name: :d
│ │ ├── opening_loc: (3...4) = "|" │ │ ├── opening_loc: (1,3)-(1,4) = "|"
│ │ └── closing_loc: (11...12) = "|" │ │ └── closing_loc: (1,11)-(1,12) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (13...14) = "}" │ └── closing_loc: (1,13)-(1,14) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

32
test/yarp/snapshots/seattlerb/block_arg_splat_arg.txt
View file

@ -1,42 +1,42 @@
@ ProgramNode (location: (0...16)) @ ProgramNode (location: (1,0)-(1,16))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...16)) @ StatementsNode (location: (1,0)-(1,16))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...16)) └── @ CallNode (location: (1,0)-(1,16))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...16)) │ @ BlockNode (location: (1,2)-(1,16))
│ ├── locals: [:b, :c, :d] │ ├── locals: [:b, :c, :d]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...14)) │ │ @ BlockParametersNode (location: (1,4)-(1,14))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...13)) │ │ │ @ ParametersNode (location: (1,5)-(1,13))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b │ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: │ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (8...10)) │ │ │ │ @ RestParameterNode (location: (1,8)-(1,10))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (9...10) = "c" │ │ │ │ ├── name_loc: (1,9)-(1,10) = "c"
│ │ │ │ └── operator_loc: (8...9) = "*" │ │ │ │ └── operator_loc: (1,8)-(1,9) = "*"
│ │ │ ├── posts: (length: 1) │ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (12...13)) │ │ │ │ └── @ RequiredParameterNode (location: (1,12)-(1,13))
│ │ │ │ └── name: :d │ │ │ │ └── name: :d
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (13...14) = "|" │ │ └── closing_loc: (1,13)-(1,14) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (15...16) = "}" │ └── closing_loc: (1,15)-(1,16) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

32
test/yarp/snapshots/seattlerb/block_args_kwargs.txt
View file

@ -1,43 +1,43 @@
@ ProgramNode (location: (0...23)) @ ProgramNode (location: (1,0)-(1,23))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...23)) @ StatementsNode (location: (1,0)-(1,23))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...23)) └── @ CallNode (location: (1,0)-(1,23))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "f" ├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...23)) │ @ BlockNode (location: (1,2)-(1,23))
│ ├── locals: [:kwargs] │ ├── locals: [:kwargs]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...14)) │ │ @ BlockParametersNode (location: (1,4)-(1,14))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...13)) │ │ │ @ ParametersNode (location: (1,5)-(1,13))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: │ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (5...13)) │ │ │ │ @ KeywordRestParameterNode (location: (1,5)-(1,13))
│ │ │ │ ├── name: :kwargs │ │ │ │ ├── name: :kwargs
│ │ │ │ ├── name_loc: (7...13) = "kwargs" │ │ │ │ ├── name_loc: (1,7)-(1,13) = "kwargs"
│ │ │ │ └── operator_loc: (5...7) = "**" │ │ │ │ └── operator_loc: (1,5)-(1,7) = "**"
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (13...14) = "|" │ │ └── closing_loc: (1,13)-(1,14) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (15...21)) │ │ @ StatementsNode (location: (1,15)-(1,21))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (15...21)) │ │ └── @ LocalVariableReadNode (location: (1,15)-(1,21))
│ │ ├── name: :kwargs │ │ ├── name: :kwargs
│ │ └── depth: 0 │ │ └── depth: 0
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (22...23) = "}" │ └── closing_loc: (1,22)-(1,23) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

28
test/yarp/snapshots/seattlerb/block_args_no_kwargs.txt
View file

@ -1,37 +1,37 @@
@ ProgramNode (location: (0...13)) @ ProgramNode (location: (1,0)-(1,13))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...13)) @ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...13)) └── @ CallNode (location: (1,0)-(1,13))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "f" ├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...13)) │ @ BlockNode (location: (1,2)-(1,13))
│ ├── locals: [] │ ├── locals: []
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...11)) │ │ @ BlockParametersNode (location: (1,4)-(1,11))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...10)) │ │ │ @ ParametersNode (location: (1,5)-(1,10))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: │ │ │ ├── keyword_rest:
│ │ │ │ @ NoKeywordsParameterNode (location: (5...10)) │ │ │ │ @ NoKeywordsParameterNode (location: (1,5)-(1,10))
│ │ │ │ ├── operator_loc: (5...7) = "**" │ │ │ │ ├── operator_loc: (1,5)-(1,7) = "**"
│ │ │ │ └── keyword_loc: (7...10) = "nil" │ │ │ │ └── keyword_loc: (1,7)-(1,10) = "nil"
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (10...11) = "|" │ │ └── closing_loc: (1,10)-(1,11) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (12...13) = "}" │ └── closing_loc: (1,12)-(1,13) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

44
test/yarp/snapshots/seattlerb/block_args_opt1.txt
View file

@ -1,32 +1,32 @@
@ ProgramNode (location: (0...24)) @ ProgramNode (location: (1,0)-(1,24))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...24)) @ StatementsNode (location: (1,0)-(1,24))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...24)) └── @ CallNode (location: (1,0)-(1,24))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "f" ├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...24)) │ @ BlockNode (location: (1,2)-(1,24))
│ ├── locals: [:a, :b] │ ├── locals: [:a, :b]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...15)) │ │ @ BlockParametersNode (location: (1,4)-(1,15))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...14)) │ │ │ @ ParametersNode (location: (1,5)-(1,14))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1) │ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...14)) │ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (8...9) = "b" │ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ ├── operator_loc: (10...11) = "=" │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (12...14)) │ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
@ -34,22 +34,22 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (14...15) = "|" │ │ └── closing_loc: (1,14)-(1,15) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (16...22)) │ │ @ StatementsNode (location: (1,16)-(1,22))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (16...22)) │ │ └── @ ArrayNode (location: (1,16)-(1,22))
│ │ ├── elements: (length: 2) │ │ ├── elements: (length: 2)
│ │ │ ├── @ LocalVariableReadNode (location: (17...18)) │ │ │ ├── @ LocalVariableReadNode (location: (1,17)-(1,18))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (20...21)) │ │ │ └── @ LocalVariableReadNode (location: (1,20)-(1,21))
│ │ │ ├── name: :b │ │ │ ├── name: :b
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── opening_loc: (16...17) = "[" │ │ ├── opening_loc: (1,16)-(1,17) = "["
│ │ └── closing_loc: (21...22) = "]" │ │ └── closing_loc: (1,21)-(1,22) = "]"
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (23...24) = "}" │ └── closing_loc: (1,23)-(1,24) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

38
test/yarp/snapshots/seattlerb/block_args_opt2.txt
View file

@ -1,37 +1,37 @@
@ ProgramNode (location: (0...18)) @ ProgramNode (location: (1,0)-(1,18))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...18)) @ StatementsNode (location: (1,0)-(1,18))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...18)) └── @ CallNode (location: (1,0)-(1,18))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "a" ├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...18)) │ @ BlockNode (location: (1,2)-(1,18))
│ ├── locals: [:b, :c] │ ├── locals: [:b, :c]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...16)) │ │ @ BlockParametersNode (location: (1,4)-(1,16))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (6...14)) │ │ │ @ ParametersNode (location: (1,6)-(1,14))
│ │ │ ├── requireds: (length: 0) │ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 2) │ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (6...9)) │ │ │ │ ├── @ OptionalParameterNode (location: (1,6)-(1,9))
│ │ │ │ │ ├── name: :b │ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (6...7) = "b" │ │ │ │ │ ├── name_loc: (1,6)-(1,7) = "b"
│ │ │ │ │ ├── operator_loc: (7...8) = "=" │ │ │ │ │ ├── operator_loc: (1,7)-(1,8) = "="
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (8...9)) │ │ │ │ │ @ IntegerNode (location: (1,8)-(1,9))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (11...14)) │ │ │ │ └── @ OptionalParameterNode (location: (1,11)-(1,14))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (11...12) = "c" │ │ │ │ ├── name_loc: (1,11)-(1,12) = "c"
│ │ │ │ ├── operator_loc: (12...13) = "=" │ │ │ │ ├── operator_loc: (1,12)-(1,13) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (13...14)) │ │ │ │ @ IntegerNode (location: (1,13)-(1,14))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
@ -39,10 +39,10 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (15...16) = "|" │ │ └── closing_loc: (1,15)-(1,16) = "|"
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (17...18) = "}" │ └── closing_loc: (1,17)-(1,18) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "a" └── name: "a"

54
test/yarp/snapshots/seattlerb/block_args_opt2_2.txt
View file

@ -1,39 +1,39 @@
@ ProgramNode (location: (0...35)) @ ProgramNode (location: (1,0)-(1,35))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...35)) @ StatementsNode (location: (1,0)-(1,35))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...35)) └── @ CallNode (location: (1,0)-(1,35))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "f" ├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...35)) │ @ BlockNode (location: (1,2)-(1,35))
│ ├── locals: [:a, :b, :c] │ ├── locals: [:a, :b, :c]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...23)) │ │ @ BlockParametersNode (location: (1,4)-(1,23))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...22)) │ │ │ @ ParametersNode (location: (1,5)-(1,22))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 2) │ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (8...14)) │ │ │ │ ├── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ │ ├── name: :b │ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (8...9) = "b" │ │ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ │ ├── operator_loc: (10...11) = "=" │ │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (12...14)) │ │ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (16...22)) │ │ │ │ └── @ OptionalParameterNode (location: (1,16)-(1,22))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (16...17) = "c" │ │ │ │ ├── name_loc: (1,16)-(1,17) = "c"
│ │ │ │ ├── operator_loc: (18...19) = "=" │ │ │ │ ├── operator_loc: (1,18)-(1,19) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (20...22)) │ │ │ │ @ IntegerNode (location: (1,20)-(1,22))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
@ -41,25 +41,25 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (22...23) = "|" │ │ └── closing_loc: (1,22)-(1,23) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (24...33)) │ │ @ StatementsNode (location: (1,24)-(1,33))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (24...33)) │ │ └── @ ArrayNode (location: (1,24)-(1,33))
│ │ ├── elements: (length: 3) │ │ ├── elements: (length: 3)
│ │ │ ├── @ LocalVariableReadNode (location: (25...26)) │ │ │ ├── @ LocalVariableReadNode (location: (1,25)-(1,26))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (28...29)) │ │ │ ├── @ LocalVariableReadNode (location: (1,28)-(1,29))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (31...32)) │ │ │ └── @ LocalVariableReadNode (location: (1,31)-(1,32))
│ │ │ ├── name: :c │ │ │ ├── name: :c
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── opening_loc: (24...25) = "[" │ │ ├── opening_loc: (1,24)-(1,25) = "["
│ │ └── closing_loc: (32...33) = "]" │ │ └── closing_loc: (1,32)-(1,33) = "]"
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (34...35) = "}" │ └── closing_loc: (1,34)-(1,35) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

62
test/yarp/snapshots/seattlerb/block_args_opt3.txt
View file

@ -1,72 +1,72 @@
@ ProgramNode (location: (0...42)) @ ProgramNode (location: (1,0)-(1,42))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...42)) @ StatementsNode (location: (1,0)-(1,42))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...42)) └── @ CallNode (location: (1,0)-(1,42))
├── receiver: ∅ ├── receiver: ∅
├── call_operator_loc: ∅ ├── call_operator_loc: ∅
├── message_loc: (0...1) = "f" ├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (2...42)) │ @ BlockNode (location: (1,2)-(1,42))
│ ├── locals: [:a, :b, :c, :d] │ ├── locals: [:a, :b, :c, :d]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (4...27)) │ │ @ BlockParametersNode (location: (1,4)-(1,27))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...26)) │ │ │ @ ParametersNode (location: (1,5)-(1,26))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6)) │ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a │ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 2) │ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (8...14)) │ │ │ │ ├── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ │ ├── name: :b │ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (8...9) = "b" │ │ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ │ ├── operator_loc: (10...11) = "=" │ │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ │ └── value: │ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (12...14)) │ │ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ │ └── flags: decimal │ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (16...22)) │ │ │ │ └── @ OptionalParameterNode (location: (1,16)-(1,22))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (16...17) = "c" │ │ │ │ ├── name_loc: (1,16)-(1,17) = "c"
│ │ │ │ ├── operator_loc: (18...19) = "=" │ │ │ │ ├── operator_loc: (1,18)-(1,19) = "="
│ │ │ │ └── value: │ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (20...22)) │ │ │ │ @ IntegerNode (location: (1,20)-(1,22))
│ │ │ │ └── flags: decimal │ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0) │ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0) │ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: │ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (24...26)) │ │ │ @ BlockParameterNode (location: (1,24)-(1,26))
│ │ │ ├── name: :d │ │ │ ├── name: :d
│ │ │ ├── name_loc: (25...26) = "d" │ │ │ ├── name_loc: (1,25)-(1,26) = "d"
│ │ │ └── operator_loc: (24...25) = "&" │ │ │ └── operator_loc: (1,24)-(1,25) = "&"
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|" │ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (26...27) = "|" │ │ └── closing_loc: (1,26)-(1,27) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (28...40)) │ │ @ StatementsNode (location: (1,28)-(1,40))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (28...40)) │ │ └── @ ArrayNode (location: (1,28)-(1,40))
│ │ ├── elements: (length: 4) │ │ ├── elements: (length: 4)
│ │ │ ├── @ LocalVariableReadNode (location: (29...30)) │ │ │ ├── @ LocalVariableReadNode (location: (1,29)-(1,30))
│ │ │ │ ├── name: :a │ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (32...33)) │ │ │ ├── @ LocalVariableReadNode (location: (1,32)-(1,33))
│ │ │ │ ├── name: :b │ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (35...36)) │ │ │ ├── @ LocalVariableReadNode (location: (1,35)-(1,36))
│ │ │ │ ├── name: :c │ │ │ │ ├── name: :c
│ │ │ │ └── depth: 0 │ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (38...39)) │ │ │ └── @ LocalVariableReadNode (location: (1,38)-(1,39))
│ │ │ ├── name: :d │ │ │ ├── name: :d
│ │ │ └── depth: 0 │ │ │ └── depth: 0
│ │ ├── opening_loc: (28...29) = "[" │ │ ├── opening_loc: (1,28)-(1,29) = "["
│ │ └── closing_loc: (39...40) = "]" │ │ └── closing_loc: (1,39)-(1,40) = "]"
│ ├── opening_loc: (2...3) = "{" │ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (41...42) = "}" │ └── closing_loc: (1,41)-(1,42) = "}"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

36
test/yarp/snapshots/seattlerb/block_break.txt
View file

@ -1,24 +1,24 @@
@ ProgramNode (location: (0...26)) @ ProgramNode (location: (1,0)-(1,26))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...26)) @ StatementsNode (location: (1,0)-(1,26))
└── body: (length: 1) └── body: (length: 1)
└── @ BreakNode (location: (0...26)) └── @ BreakNode (location: (1,0)-(1,26))
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (6...26)) │ @ ArgumentsNode (location: (1,6)-(1,26))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ CallNode (location: (6...26)) │ └── @ CallNode (location: (1,6)-(1,26))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (6...9) = "foo" │ ├── message_loc: (1,6)-(1,9) = "foo"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (10...13)) │ │ @ ArgumentsNode (location: (1,10)-(1,13))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (10...13)) │ │ └── @ CallNode (location: (1,10)-(1,13))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (10...13) = "arg" │ │ ├── message_loc: (1,10)-(1,13) = "arg"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -27,14 +27,14 @@
│ │ └── name: "arg" │ │ └── name: "arg"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (14...26)) │ │ @ BlockNode (location: (1,14)-(1,26))
│ │ ├── locals: [:bar] │ │ ├── locals: [:bar]
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (17...22)) │ │ │ @ BlockParametersNode (location: (1,17)-(1,22))
│ │ │ ├── parameters: │ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (18...21)) │ │ │ │ @ ParametersNode (location: (1,18)-(1,21))
│ │ │ │ ├── requireds: (length: 1) │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (18...21)) │ │ │ │ │ └── @ RequiredParameterNode (location: (1,18)-(1,21))
│ │ │ │ │ └── name: :bar │ │ │ │ │ └── name: :bar
│ │ │ │ ├── optionals: (length: 0) │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅ │ │ │ │ ├── rest: ∅
@ -43,11 +43,11 @@
│ │ │ │ ├── keyword_rest: ∅ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅ │ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0) │ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (17...18) = "|" │ │ │ ├── opening_loc: (1,17)-(1,18) = "|"
│ │ │ └── closing_loc: (21...22) = "|" │ │ │ └── closing_loc: (1,21)-(1,22) = "|"
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (14...16) = "do" │ │ ├── opening_loc: (1,14)-(1,16) = "do"
│ │ └── closing_loc: (23...26) = "end" │ │ └── closing_loc: (1,23)-(1,26) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "foo" │ └── name: "foo"
└── keyword_loc: (0...5) = "break" └── keyword_loc: (1,0)-(1,5) = "break"

48
test/yarp/snapshots/seattlerb/block_call_defn_call_block_call.txt
View file

@ -1,24 +1,24 @@
@ ProgramNode (location: (0...30)) @ ProgramNode (location: (1,0)-(4,11))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...30)) @ StatementsNode (location: (1,0)-(4,11))
└── body: (length: 2) └── body: (length: 2)
├── @ CallNode (location: (0...18)) ├── @ CallNode (location: (1,0)-(3,4))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a" │ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (2...18)) │ │ @ ArgumentsNode (location: (1,2)-(3,4))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ DefNode (location: (2...18)) │ │ └── @ DefNode (location: (1,2)-(3,4))
│ │ ├── name: :b │ │ ├── name: :b
│ │ ├── name_loc: (6...7) = "b" │ │ ├── name_loc: (1,6)-(1,7) = "b"
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (8...9)) │ │ │ @ ParametersNode (location: (1,8)-(1,9))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (8...9)) │ │ │ │ └── @ RequiredParameterNode (location: (1,8)-(1,9))
│ │ │ │ └── name: :c │ │ │ │ └── name: :c
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -27,12 +27,12 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (12...13)) │ │ │ @ StatementsNode (location: (2,1)-(2,2))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (12...13)) │ │ │ └── @ CallNode (location: (2,1)-(2,2))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (12...13) = "d" │ │ │ ├── message_loc: (2,1)-(2,2) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
@ -40,39 +40,39 @@
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ ├── locals: [:c] │ │ ├── locals: [:c]
│ │ ├── def_keyword_loc: (2...5) = "def" │ │ ├── def_keyword_loc: (1,2)-(1,5) = "def"
│ │ ├── operator_loc: ∅ │ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: (7...8) = "(" │ │ ├── lparen_loc: (1,7)-(1,8) = "("
│ │ ├── rparen_loc: (9...10) = ")" │ │ ├── rparen_loc: (1,9)-(1,10) = ")"
│ │ ├── equal_loc: ∅ │ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (15...18) = "end" │ │ └── end_keyword_loc: (3,1)-(3,4) = "end"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "a" │ └── name: "a"
└── @ CallNode (location: (20...30)) └── @ CallNode (location: (4,1)-(4,11))
├── receiver: ├── receiver:
│ @ CallNode (location: (20...21)) │ @ CallNode (location: (4,1)-(4,2))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (20...21) = "e" │ ├── message_loc: (4,1)-(4,2) = "e"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "e" │ └── name: "e"
├── call_operator_loc: (21...22) = "." ├── call_operator_loc: (4,2)-(4,3) = "."
├── message_loc: (22...23) = "f" ├── message_loc: (4,3)-(4,4) = "f"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (24...30)) │ @ BlockNode (location: (4,5)-(4,11))
│ ├── locals: [] │ ├── locals: []
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (24...26) = "do" │ ├── opening_loc: (4,5)-(4,7) = "do"
│ └── closing_loc: (27...30) = "end" │ └── closing_loc: (4,8)-(4,11) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "f" └── name: "f"

64
test/yarp/snapshots/seattlerb/block_call_dot_op2_brace_block.txt
View file

@ -1,74 +1,74 @@
@ ProgramNode (location: (0...31)) @ ProgramNode (location: (1,0)-(1,31))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...31)) @ StatementsNode (location: (1,0)-(1,31))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...31)) └── @ CallNode (location: (1,0)-(1,31))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...16)) │ @ CallNode (location: (1,0)-(1,16))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (0...1)) │ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a" │ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "." │ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (2...3) = "b" │ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7)) │ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7)) │ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c" │ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: (5...6) = "(" │ │ ├── opening_loc: (1,5)-(1,6) = "("
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: (6...7) = ")" │ │ ├── closing_loc: (1,6)-(1,7) = ")"
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "c" │ │ └── name: "c"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (8...16)) │ │ @ BlockNode (location: (1,8)-(1,16))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (11...12)) │ │ │ @ StatementsNode (location: (1,11)-(1,12))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...12)) │ │ │ └── @ CallNode (location: (1,11)-(1,12))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...12) = "d" │ │ │ ├── message_loc: (1,11)-(1,12) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ ├── opening_loc: (8...10) = "do" │ │ ├── opening_loc: (1,8)-(1,10) = "do"
│ │ └── closing_loc: (13...16) = "end" │ │ └── closing_loc: (1,13)-(1,16) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "b" │ └── name: "b"
├── call_operator_loc: (16...17) = "." ├── call_operator_loc: (1,16)-(1,17) = "."
├── message_loc: (17...18) = "e" ├── message_loc: (1,17)-(1,18) = "e"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (19...31)) │ @ BlockNode (location: (1,19)-(1,31))
│ ├── locals: [:f] │ ├── locals: [:f]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (22...25)) │ │ @ BlockParametersNode (location: (1,22)-(1,25))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (23...24)) │ │ │ @ ParametersNode (location: (1,23)-(1,24))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (23...24)) │ │ │ │ └── @ RequiredParameterNode (location: (1,23)-(1,24))
│ │ │ │ └── name: :f │ │ │ │ └── name: :f
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -77,22 +77,22 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (22...23) = "|" │ │ ├── opening_loc: (1,22)-(1,23) = "|"
│ │ └── closing_loc: (24...25) = "|" │ │ └── closing_loc: (1,24)-(1,25) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (26...27)) │ │ @ StatementsNode (location: (1,26)-(1,27))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (26...27)) │ │ └── @ CallNode (location: (1,26)-(1,27))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (26...27) = "g" │ │ ├── message_loc: (1,26)-(1,27) = "g"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "g" │ │ └── name: "g"
│ ├── opening_loc: (19...21) = "do" │ ├── opening_loc: (1,19)-(1,21) = "do"
│ └── closing_loc: (28...31) = "end" │ └── closing_loc: (1,28)-(1,31) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "e" └── name: "e"

70
test/yarp/snapshots/seattlerb/block_call_dot_op2_cmd_args_do_block.txt
View file

@ -1,70 +1,70 @@
@ ProgramNode (location: (0...33)) @ ProgramNode (location: (1,0)-(1,33))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...33)) @ StatementsNode (location: (1,0)-(1,33))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...33)) └── @ CallNode (location: (1,0)-(1,33))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...16)) │ @ CallNode (location: (1,0)-(1,16))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (0...1)) │ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a" │ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "." │ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (2...3) = "b" │ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7)) │ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7)) │ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c" │ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: (5...6) = "(" │ │ ├── opening_loc: (1,5)-(1,6) = "("
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: (6...7) = ")" │ │ ├── closing_loc: (1,6)-(1,7) = ")"
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: ∅ │ │ ├── flags: ∅
│ │ └── name: "c" │ │ └── name: "c"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (8...16)) │ │ @ BlockNode (location: (1,8)-(1,16))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (11...12)) │ │ │ @ StatementsNode (location: (1,11)-(1,12))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...12)) │ │ │ └── @ CallNode (location: (1,11)-(1,12))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...12) = "d" │ │ │ ├── message_loc: (1,11)-(1,12) = "d"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "d" │ │ │ └── name: "d"
│ │ ├── opening_loc: (8...10) = "do" │ │ ├── opening_loc: (1,8)-(1,10) = "do"
│ │ └── closing_loc: (13...16) = "end" │ │ └── closing_loc: (1,13)-(1,16) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "b" │ └── name: "b"
├── call_operator_loc: (16...17) = "." ├── call_operator_loc: (1,16)-(1,17) = "."
├── message_loc: (17...18) = "e" ├── message_loc: (1,17)-(1,18) = "e"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ├── arguments:
│ @ ArgumentsNode (location: (19...20)) │ @ ArgumentsNode (location: (1,19)-(1,20))
│ └── arguments: (length: 1) │ └── arguments: (length: 1)
│ └── @ CallNode (location: (19...20)) │ └── @ CallNode (location: (1,19)-(1,20))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (19...20) = "f" │ ├── message_loc: (1,19)-(1,20) = "f"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
@ -73,14 +73,14 @@
│ └── name: "f" │ └── name: "f"
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (21...33)) │ @ BlockNode (location: (1,21)-(1,33))
│ ├── locals: [:g] │ ├── locals: [:g]
│ ├── parameters: │ ├── parameters:
│ │ @ BlockParametersNode (location: (24...27)) │ │ @ BlockParametersNode (location: (1,24)-(1,27))
│ │ ├── parameters: │ │ ├── parameters:
│ │ │ @ ParametersNode (location: (25...26)) │ │ │ @ ParametersNode (location: (1,25)-(1,26))
│ │ │ ├── requireds: (length: 1) │ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (25...26)) │ │ │ │ └── @ RequiredParameterNode (location: (1,25)-(1,26))
│ │ │ │ └── name: :g │ │ │ │ └── name: :g
│ │ │ ├── optionals: (length: 0) │ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅ │ │ │ ├── rest: ∅
@ -89,22 +89,22 @@
│ │ │ ├── keyword_rest: ∅ │ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅ │ │ │ └── block: ∅
│ │ ├── locals: (length: 0) │ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (24...25) = "|" │ │ ├── opening_loc: (1,24)-(1,25) = "|"
│ │ └── closing_loc: (26...27) = "|" │ │ └── closing_loc: (1,26)-(1,27) = "|"
│ ├── body: │ ├── body:
│ │ @ StatementsNode (location: (28...29)) │ │ @ StatementsNode (location: (1,28)-(1,29))
│ │ └── body: (length: 1) │ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (28...29)) │ │ └── @ CallNode (location: (1,28)-(1,29))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (28...29) = "h" │ │ ├── message_loc: (1,28)-(1,29) = "h"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "h" │ │ └── name: "h"
│ ├── opening_loc: (21...23) = "do" │ ├── opening_loc: (1,21)-(1,23) = "do"
│ └── closing_loc: (30...33) = "end" │ └── closing_loc: (1,30)-(1,33) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "e" └── name: "e"

32
test/yarp/snapshots/seattlerb/block_call_operation_colon.txt
View file

@ -1,32 +1,32 @@
@ ProgramNode (location: (0...15)) @ ProgramNode (location: (1,0)-(1,15))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...15)) @ StatementsNode (location: (1,0)-(1,15))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...15)) └── @ CallNode (location: (1,0)-(1,15))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...12)) │ @ CallNode (location: (1,0)-(1,12))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (0...1)) │ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a" │ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "." │ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (2...3) = "b" │ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...5)) │ │ @ ArgumentsNode (location: (1,4)-(1,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...5)) │ │ └── @ CallNode (location: (1,4)-(1,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c" │ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -35,16 +35,16 @@
│ │ └── name: "c" │ │ └── name: "c"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (6...12)) │ │ @ BlockNode (location: (1,6)-(1,12))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (6...8) = "do" │ │ ├── opening_loc: (1,6)-(1,8) = "do"
│ │ └── closing_loc: (9...12) = "end" │ │ └── closing_loc: (1,9)-(1,12) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "b" │ └── name: "b"
├── call_operator_loc: (12...14) = "::" ├── call_operator_loc: (1,12)-(1,14) = "::"
├── message_loc: (14...15) = "d" ├── message_loc: (1,14)-(1,15) = "d"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

32
test/yarp/snapshots/seattlerb/block_call_operation_dot.txt
View file

@ -1,32 +1,32 @@
@ ProgramNode (location: (0...14)) @ ProgramNode (location: (1,0)-(1,14))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...14)) @ StatementsNode (location: (1,0)-(1,14))
└── body: (length: 1) └── body: (length: 1)
└── @ CallNode (location: (0...14)) └── @ CallNode (location: (1,0)-(1,14))
├── receiver: ├── receiver:
│ @ CallNode (location: (0...12)) │ @ CallNode (location: (1,0)-(1,12))
│ ├── receiver: │ ├── receiver:
│ │ @ CallNode (location: (0...1)) │ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a" │ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
│ │ ├── block: ∅ │ │ ├── block: ∅
│ │ ├── flags: variable_call │ │ ├── flags: variable_call
│ │ └── name: "a" │ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "." │ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (2...3) = "b" │ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (4...5)) │ │ @ ArgumentsNode (location: (1,4)-(1,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...5)) │ │ └── @ CallNode (location: (1,4)-(1,5))
│ │ ├── receiver: ∅ │ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅ │ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c" │ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: ∅ │ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅ │ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅ │ │ ├── closing_loc: ∅
@ -35,16 +35,16 @@
│ │ └── name: "c" │ │ └── name: "c"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: │ ├── block:
│ │ @ BlockNode (location: (6...12)) │ │ @ BlockNode (location: (1,6)-(1,12))
│ │ ├── locals: [] │ │ ├── locals: []
│ │ ├── parameters: ∅ │ │ ├── parameters: ∅
│ │ ├── body: ∅ │ │ ├── body: ∅
│ │ ├── opening_loc: (6...8) = "do" │ │ ├── opening_loc: (1,6)-(1,8) = "do"
│ │ └── closing_loc: (9...12) = "end" │ │ └── closing_loc: (1,9)-(1,12) = "end"
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "b" │ └── name: "b"
├── call_operator_loc: (12...13) = "." ├── call_operator_loc: (1,12)-(1,13) = "."
├── message_loc: (13...14) = "d" ├── message_loc: (1,13)-(1,14) = "d"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅

38
test/yarp/snapshots/seattlerb/block_call_paren_call_block_call.txt
View file

@ -1,59 +1,59 @@
@ ProgramNode (location: (0...16)) @ ProgramNode (location: (1,0)-(2,10))
├── locals: [] ├── locals: []
└── statements: └── statements:
@ StatementsNode (location: (0...16)) @ StatementsNode (location: (1,0)-(2,10))
└── body: (length: 2) └── body: (length: 2)
├── @ CallNode (location: (0...5)) ├── @ CallNode (location: (1,0)-(1,5))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a" │ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: │ ├── arguments:
│ │ @ ArgumentsNode (location: (2...5)) │ │ @ ArgumentsNode (location: (1,2)-(1,5))
│ │ └── arguments: (length: 1) │ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (2...5)) │ │ └── @ ParenthesesNode (location: (1,2)-(1,5))
│ │ ├── body: │ │ ├── body:
│ │ │ @ StatementsNode (location: (3...4)) │ │ │ @ StatementsNode (location: (1,3)-(1,4))
│ │ │ └── body: (length: 1) │ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (3...4)) │ │ │ └── @ CallNode (location: (1,3)-(1,4))
│ │ │ ├── receiver: ∅ │ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅ │ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (3...4) = "b" │ │ │ ├── message_loc: (1,3)-(1,4) = "b"
│ │ │ ├── opening_loc: ∅ │ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅ │ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅ │ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅ │ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call │ │ │ ├── flags: variable_call
│ │ │ └── name: "b" │ │ │ └── name: "b"
│ │ ├── opening_loc: (2...3) = "(" │ │ ├── opening_loc: (1,2)-(1,3) = "("
│ │ └── closing_loc: (4...5) = ")" │ │ └── closing_loc: (1,4)-(1,5) = ")"
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: ∅ │ ├── flags: ∅
│ └── name: "a" │ └── name: "a"
└── @ CallNode (location: (6...16)) └── @ CallNode (location: (2,0)-(2,10))
├── receiver: ├── receiver:
│ @ CallNode (location: (6...7)) │ @ CallNode (location: (2,0)-(2,1))
│ ├── receiver: ∅ │ ├── receiver: ∅
│ ├── call_operator_loc: ∅ │ ├── call_operator_loc: ∅
│ ├── message_loc: (6...7) = "c" │ ├── message_loc: (2,0)-(2,1) = "c"
│ ├── opening_loc: ∅ │ ├── opening_loc: ∅
│ ├── arguments: ∅ │ ├── arguments: ∅
│ ├── closing_loc: ∅ │ ├── closing_loc: ∅
│ ├── block: ∅ │ ├── block: ∅
│ ├── flags: variable_call │ ├── flags: variable_call
│ └── name: "c" │ └── name: "c"
├── call_operator_loc: (7...8) = "." ├── call_operator_loc: (2,1)-(2,2) = "."
├── message_loc: (8...9) = "d" ├── message_loc: (2,2)-(2,3) = "d"
├── opening_loc: ∅ ├── opening_loc: ∅
├── arguments: ∅ ├── arguments: ∅
├── closing_loc: ∅ ├── closing_loc: ∅
├── block: ├── block:
│ @ BlockNode (location: (10...16)) │ @ BlockNode (location: (2,4)-(2,10))
│ ├── locals: [] │ ├── locals: []
│ ├── parameters: ∅ │ ├── parameters: ∅
│ ├── body: ∅ │ ├── body: ∅
│ ├── opening_loc: (10...12) = "do" │ ├── opening_loc: (2,4)-(2,6) = "do"
│ └── closing_loc: (13...16) = "end" │ └── closing_loc: (2,7)-(2,10) = "end"
├── flags: ∅ ├── flags: ∅
└── name: "d" └── name: "d"

Some files were not shown because too many files have changed in this diff Show more