archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-09-21 03:24:00 +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.
def inspect
"#<YARP::Location @start_offset=#{@start_offset} @length=#{@length}>"
"#<YARP::Location @start_offset=#{@start_offset} @length=#{@length} start_line=#{start_line}>"
end
# The source code that this location represents.
@ -117,7 +117,7 @@ module YARP
end
def pretty_print(q)
q.text("(#{start_offset}...#{end_offset})")
q.text("(#{start_line},#{start_column})-(#{end_line},#{end_column}))")
end
def ==(other)
@ -333,7 +333,7 @@ module YARP
# for any given node.
def header(node)
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 << ")\n"
output
@ -357,7 +357,7 @@ module YARP
# Generates a string that represents a location field on a node.
def location(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
"∅"
end

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

@ -1,173 +1,173 @@
@ ProgramNode (location: (0...199))
@ ProgramNode (location: (1,0)-(23,11))
├── locals: []
└── statements:
@ StatementsNode (location: (0...199))
@ StatementsNode (location: (1,0)-(23,11))
└── body: (length: 12)
├── @ AliasMethodNode (location: (0...15))
├── @ AliasMethodNode (location: (1,0)-(1,15))
│ ├── new_name:
│ │ @ SymbolNode (location: (6...10))
│ │ ├── opening_loc: (6...7) = ":"
│ │ ├── value_loc: (7...10) = "foo"
│ │ @ SymbolNode (location: (1,6)-(1,10))
│ │ ├── opening_loc: (1,6)-(1,7) = ":"
│ │ ├── value_loc: (1,7)-(1,10) = "foo"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo"
│ ├── old_name:
│ │ @ SymbolNode (location: (11...15))
│ │ ├── opening_loc: (11...12) = ":"
│ │ ├── value_loc: (12...15) = "bar"
│ │ @ SymbolNode (location: (1,11)-(1,15))
│ │ ├── opening_loc: (1,11)-(1,12) = ":"
│ │ ├── value_loc: (1,12)-(1,15) = "bar"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "bar"
│ └── keyword_loc: (0...5) = "alias"
├── @ AliasMethodNode (location: (17...38))
│ └── keyword_loc: (1,0)-(1,5) = "alias"
├── @ AliasMethodNode (location: (3,0)-(3,21))
│ ├── new_name:
│ │ @ SymbolNode (location: (23...30))
│ │ ├── opening_loc: (23...26) = "%s["
│ │ ├── value_loc: (26...29) = "abc"
│ │ ├── closing_loc: (29...30) = "]"
│ │ @ SymbolNode (location: (3,6)-(3,13))
│ │ ├── opening_loc: (3,6)-(3,9) = "%s["
│ │ ├── value_loc: (3,9)-(3,12) = "abc"
│ │ ├── closing_loc: (3,12)-(3,13) = "]"
│ │ └── unescaped: "abc"
│ ├── old_name:
│ │ @ SymbolNode (location: (31...38))
│ │ ├── opening_loc: (31...34) = "%s["
│ │ ├── value_loc: (34...37) = "def"
│ │ ├── closing_loc: (37...38) = "]"
│ │ @ SymbolNode (location: (3,14)-(3,21))
│ │ ├── opening_loc: (3,14)-(3,17) = "%s["
│ │ ├── value_loc: (3,17)-(3,20) = "def"
│ │ ├── closing_loc: (3,20)-(3,21) = "]"
│ │ └── unescaped: "def"
│ └── keyword_loc: (17...22) = "alias"
├── @ AliasMethodNode (location: (40...59))
│ └── keyword_loc: (3,0)-(3,5) = "alias"
├── @ AliasMethodNode (location: (5,0)-(5,19))
│ ├── new_name:
│ │ @ SymbolNode (location: (46...52))
│ │ ├── opening_loc: (46...48) = ":'"
│ │ ├── value_loc: (48...51) = "abc"
│ │ ├── closing_loc: (51...52) = "'"
│ │ @ SymbolNode (location: (5,6)-(5,12))
│ │ ├── opening_loc: (5,6)-(5,8) = ":'"
│ │ ├── value_loc: (5,8)-(5,11) = "abc"
│ │ ├── closing_loc: (5,11)-(5,12) = "'"
│ │ └── unescaped: "abc"
│ ├── old_name:
│ │ @ SymbolNode (location: (53...59))
│ │ ├── opening_loc: (53...55) = ":'"
│ │ ├── value_loc: (55...58) = "def"
│ │ ├── closing_loc: (58...59) = "'"
│ │ @ SymbolNode (location: (5,13)-(5,19))
│ │ ├── opening_loc: (5,13)-(5,15) = ":'"
│ │ ├── value_loc: (5,15)-(5,18) = "def"
│ │ ├── closing_loc: (5,18)-(5,19) = "'"
│ │ └── unescaped: "def"
│ └── keyword_loc: (40...45) = "alias"
├── @ AliasMethodNode (location: (61...84))
│ └── keyword_loc: (5,0)-(5,5) = "alias"
├── @ AliasMethodNode (location: (7,0)-(7,23))
│ ├── new_name:
│ │ @ InterpolatedSymbolNode (location: (67...77))
│ │ ├── opening_loc: (67...69) = ":\""
│ │ @ InterpolatedSymbolNode (location: (7,6)-(7,16))
│ │ ├── opening_loc: (7,6)-(7,8) = ":\""
│ │ ├── parts: (length: 2)
│ │ │ ├── @ StringNode (location: (69...72))
│ │ │ ├── @ StringNode (location: (7,8)-(7,11))
│ │ │ │ ├── flags: ∅
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── content_loc: (69...72) = "abc"
│ │ │ │ ├── content_loc: (7,8)-(7,11) = "abc"
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "abc"
│ │ │ └── @ EmbeddedStatementsNode (location: (72...76))
│ │ │ ├── opening_loc: (72...74) = "\#{"
│ │ │ └── @ EmbeddedStatementsNode (location: (7,11)-(7,15))
│ │ │ ├── opening_loc: (7,11)-(7,13) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (74...75))
│ │ │ │ @ StatementsNode (location: (7,13)-(7,14))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (74...75))
│ │ │ │ └── @ IntegerNode (location: (7,13)-(7,14))
│ │ │ │ └── flags: decimal
│ │ │ └── closing_loc: (75...76) = "}"
│ │ └── closing_loc: (76...77) = "\""
│ │ │ └── closing_loc: (7,14)-(7,15) = "}"
│ │ └── closing_loc: (7,15)-(7,16) = "\""
│ ├── old_name:
│ │ @ SymbolNode (location: (78...84))
│ │ ├── opening_loc: (78...80) = ":'"
│ │ ├── value_loc: (80...83) = "def"
│ │ ├── closing_loc: (83...84) = "'"
│ │ @ SymbolNode (location: (7,17)-(7,23))
│ │ ├── opening_loc: (7,17)-(7,19) = ":'"
│ │ ├── value_loc: (7,19)-(7,22) = "def"
│ │ ├── closing_loc: (7,22)-(7,23) = "'"
│ │ └── unescaped: "def"
│ └── keyword_loc: (61...66) = "alias"
├── @ AliasGlobalVariableNode (location: (86...97))
│ └── keyword_loc: (7,0)-(7,5) = "alias"
├── @ AliasGlobalVariableNode (location: (9,0)-(9,11))
│ ├── new_name:
│ │ @ GlobalVariableReadNode (location: (92...94))
│ │ @ GlobalVariableReadNode (location: (9,6)-(9,8))
│ │ └── name: :$a
│ ├── old_name:
│ │ @ BackReferenceReadNode (location: (95...97))
│ └── keyword_loc: (86...91) = "alias"
├── @ AliasMethodNode (location: (99...112))
│ │ @ BackReferenceReadNode (location: (9,9)-(9,11))
│ └── keyword_loc: (9,0)-(9,5) = "alias"
├── @ AliasMethodNode (location: (11,0)-(11,13))
│ ├── new_name:
│ │ @ SymbolNode (location: (105...108))
│ │ @ SymbolNode (location: (11,6)-(11,9))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (105...108) = "foo"
│ │ ├── value_loc: (11,6)-(11,9) = "foo"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo"
│ ├── old_name:
│ │ @ SymbolNode (location: (109...112))
│ │ @ SymbolNode (location: (11,10)-(11,13))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (109...112) = "bar"
│ │ ├── value_loc: (11,10)-(11,13) = "bar"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "bar"
│ └── keyword_loc: (99...104) = "alias"
├── @ AliasGlobalVariableNode (location: (114...129))
│ └── keyword_loc: (11,0)-(11,5) = "alias"
├── @ AliasGlobalVariableNode (location: (13,0)-(13,15))
│ ├── new_name:
│ │ @ GlobalVariableReadNode (location: (120...124))
│ │ @ GlobalVariableReadNode (location: (13,6)-(13,10))
│ │ └── name: :$foo
│ ├── old_name:
│ │ @ GlobalVariableReadNode (location: (125...129))
│ │ @ GlobalVariableReadNode (location: (13,11)-(13,15))
│ │ └── name: :$bar
│ └── keyword_loc: (114...119) = "alias"
├── @ AliasMethodNode (location: (131...143))
│ └── keyword_loc: (13,0)-(13,5) = "alias"
├── @ AliasMethodNode (location: (15,0)-(15,12))
│ ├── new_name:
│ │ @ SymbolNode (location: (137...140))
│ │ @ SymbolNode (location: (15,6)-(15,9))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (137...140) = "foo"
│ │ ├── value_loc: (15,6)-(15,9) = "foo"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo"
│ ├── old_name:
│ │ @ SymbolNode (location: (141...143))
│ │ @ SymbolNode (location: (15,10)-(15,12))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (141...143) = "if"
│ │ ├── value_loc: (15,10)-(15,12) = "if"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "if"
│ └── keyword_loc: (131...136) = "alias"
├── @ AliasMethodNode (location: (145...158))
│ └── keyword_loc: (15,0)-(15,5) = "alias"
├── @ AliasMethodNode (location: (17,0)-(17,13))
│ ├── new_name:
│ │ @ SymbolNode (location: (151...154))
│ │ @ SymbolNode (location: (17,6)-(17,9))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (151...154) = "foo"
│ │ ├── value_loc: (17,6)-(17,9) = "foo"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "foo"
│ ├── old_name:
│ │ @ SymbolNode (location: (155...158))
│ │ @ SymbolNode (location: (17,10)-(17,13))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (155...158) = "<=>"
│ │ ├── value_loc: (17,10)-(17,13) = "<=>"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "<=>"
│ └── keyword_loc: (145...150) = "alias"
├── @ AliasMethodNode (location: (160...175))
│ └── keyword_loc: (17,0)-(17,5) = "alias"
├── @ AliasMethodNode (location: (19,0)-(19,15))
│ ├── new_name:
│ │ @ SymbolNode (location: (166...169))
│ │ ├── opening_loc: (166...167) = ":"
│ │ ├── value_loc: (167...169) = "=="
│ │ @ SymbolNode (location: (19,6)-(19,9))
│ │ ├── opening_loc: (19,6)-(19,7) = ":"
│ │ ├── value_loc: (19,7)-(19,9) = "=="
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "=="
│ ├── old_name:
│ │ @ SymbolNode (location: (170...175))
│ │ ├── opening_loc: (170...171) = ":"
│ │ ├── value_loc: (171...175) = "eql?"
│ │ @ SymbolNode (location: (19,10)-(19,15))
│ │ ├── opening_loc: (19,10)-(19,11) = ":"
│ │ ├── value_loc: (19,11)-(19,15) = "eql?"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "eql?"
│ └── keyword_loc: (160...165) = "alias"
├── @ AliasMethodNode (location: (177...186))
│ └── keyword_loc: (19,0)-(19,5) = "alias"
├── @ AliasMethodNode (location: (21,0)-(21,9))
│ ├── new_name:
│ │ @ SymbolNode (location: (183...184))
│ │ @ SymbolNode (location: (21,6)-(21,7))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (183...184) = "A"
│ │ ├── value_loc: (21,6)-(21,7) = "A"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "A"
│ ├── old_name:
│ │ @ SymbolNode (location: (185...186))
│ │ @ SymbolNode (location: (21,8)-(21,9))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (185...186) = "B"
│ │ ├── value_loc: (21,8)-(21,9) = "B"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "B"
│ └── keyword_loc: (177...182) = "alias"
└── @ AliasMethodNode (location: (188...199))
│ └── keyword_loc: (21,0)-(21,5) = "alias"
└── @ AliasMethodNode (location: (23,0)-(23,11))
├── new_name:
│ @ SymbolNode (location: (194...196))
│ ├── opening_loc: (194...195) = ":"
│ ├── value_loc: (195...196) = "A"
│ @ SymbolNode (location: (23,6)-(23,8))
│ ├── opening_loc: (23,6)-(23,7) = ":"
│ ├── value_loc: (23,7)-(23,8) = "A"
│ ├── closing_loc: ∅
│ └── unescaped: "A"
├── old_name:
│ @ SymbolNode (location: (197...199))
│ ├── opening_loc: (197...198) = ":"
│ ├── value_loc: (198...199) = "B"
│ @ SymbolNode (location: (23,9)-(23,11))
│ ├── opening_loc: (23,9)-(23,10) = ":"
│ ├── value_loc: (23,10)-(23,11) = "B"
│ ├── closing_loc: ∅
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...75))
@ StatementsNode (location: (1,0)-(13,8))
└── body: (length: 7)
├── @ CallNode (location: (0...8))
├── @ CallNode (location: (1,0)-(1,8))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...3) = "foo"
│ ├── message_loc: (1,0)-(1,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...8))
│ │ @ ArgumentsNode (location: (1,4)-(1,8))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...8))
│ │ └── @ CallNode (location: (1,4)-(1,8))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (5...8))
│ │ │ @ CallNode (location: (1,5)-(1,8))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (5...8) = "bar"
│ │ │ ├── message_loc: (1,5)-(1,8) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -24,7 +24,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "!"
│ │ ├── message_loc: (1,4)-(1,5) = "!"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -35,14 +35,14 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (10...18))
├── @ CallNode (location: (3,0)-(3,8))
│ ├── receiver:
│ │ @ CallNode (location: (10...14))
│ │ @ CallNode (location: (3,0)-(3,4))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (11...14))
│ │ │ @ CallNode (location: (3,1)-(3,4))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...14) = "foo"
│ │ │ ├── message_loc: (3,1)-(3,4) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -50,7 +50,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (10...11) = "-"
│ │ ├── message_loc: (3,0)-(3,1) = "-"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -58,15 +58,15 @@
│ │ ├── flags: ∅
│ │ └── name: "-@"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (14...15) = "*"
│ ├── message_loc: (3,4)-(3,5) = "*"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (15...18))
│ │ @ ArgumentsNode (location: (3,5)-(3,8))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (15...18))
│ │ └── @ CallNode (location: (3,5)-(3,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (15...18) = "bar"
│ │ ├── message_loc: (3,5)-(3,8) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -77,14 +77,14 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "*"
├── @ CallNode (location: (20...29))
├── @ CallNode (location: (5,0)-(5,9))
│ ├── receiver:
│ │ @ CallNode (location: (20...24))
│ │ @ CallNode (location: (5,0)-(5,4))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (21...24))
│ │ │ @ CallNode (location: (5,1)-(5,4))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (21...24) = "foo"
│ │ │ ├── message_loc: (5,1)-(5,4) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -92,7 +92,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (20...21) = "+"
│ │ ├── message_loc: (5,0)-(5,1) = "+"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -100,15 +100,15 @@
│ │ ├── flags: ∅
│ │ └── name: "+@"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (24...26) = "**"
│ ├── message_loc: (5,4)-(5,6) = "**"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (26...29))
│ │ @ ArgumentsNode (location: (5,6)-(5,9))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (26...29))
│ │ └── @ CallNode (location: (5,6)-(5,9))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (26...29) = "bar"
│ │ ├── message_loc: (5,6)-(5,9) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -119,20 +119,20 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "**"
├── @ CallNode (location: (31...39))
├── @ CallNode (location: (7,0)-(7,8))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (31...34) = "foo"
│ ├── message_loc: (7,0)-(7,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (35...39))
│ │ @ ArgumentsNode (location: (7,4)-(7,8))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (35...39))
│ │ └── @ CallNode (location: (7,4)-(7,8))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (36...39))
│ │ │ @ CallNode (location: (7,5)-(7,8))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (36...39) = "bar"
│ │ │ ├── message_loc: (7,5)-(7,8) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -140,7 +140,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (35...36) = "~"
│ │ ├── message_loc: (7,4)-(7,5) = "~"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -151,14 +151,14 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (41...58))
├── @ CallNode (location: (9,0)-(9,17))
│ ├── receiver:
│ │ @ CallNode (location: (41...51))
│ │ @ CallNode (location: (9,0)-(9,10))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (41...44))
│ │ │ @ CallNode (location: (9,0)-(9,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (41...44) = "foo"
│ │ │ ├── message_loc: (9,0)-(9,3) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -166,15 +166,15 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (45...47) = "<<"
│ │ ├── message_loc: (9,4)-(9,6) = "<<"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (48...51))
│ │ │ @ ArgumentsNode (location: (9,7)-(9,10))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ CallNode (location: (48...51))
│ │ │ └── @ CallNode (location: (9,7)-(9,10))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (48...51) = "bar"
│ │ │ ├── message_loc: (9,7)-(9,10) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -186,15 +186,15 @@
│ │ ├── flags: ∅
│ │ └── name: "<<"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (52...54) = "<<"
│ ├── message_loc: (9,11)-(9,13) = "<<"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (55...58))
│ │ @ ArgumentsNode (location: (9,14)-(9,17))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (55...58))
│ │ └── @ CallNode (location: (9,14)-(9,17))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (55...58) = "baz"
│ │ ├── message_loc: (9,14)-(9,17) = "baz"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -205,38 +205,38 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "<<"
├── @ CallNode (location: (60...65))
├── @ CallNode (location: (11,0)-(11,5))
│ ├── receiver:
│ │ @ CallNode (location: (61...65))
│ │ @ CallNode (location: (11,1)-(11,5))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (61...62))
│ │ │ @ IntegerNode (location: (11,1)-(11,2))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (62...64) = "**"
│ │ ├── message_loc: (11,2)-(11,4) = "**"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (64...65))
│ │ │ @ ArgumentsNode (location: (11,4)-(11,5))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (64...65))
│ │ │ └── @ IntegerNode (location: (11,4)-(11,5))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "**"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (60...61) = "-"
│ ├── message_loc: (11,0)-(11,1) = "-"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "-@"
└── @ CallNode (location: (67...75))
└── @ CallNode (location: (13,0)-(13,8))
├── receiver:
│ @ IntegerNode (location: (67...69))
│ @ IntegerNode (location: (13,0)-(13,2))
│ └── flags: decimal
├── call_operator_loc: (69...70) = "."
├── message_loc: (70...75) = "zero?"
├── call_operator_loc: (13,2)-(13,3) = "."
├── message_loc: (13,3)-(13,8) = "zero?"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...211))
@ StatementsNode (location: (1,0)-(21,15))
└── body: (length: 5)
├── @ BeginNode (location: (0...20))
│ ├── begin_keyword_loc: (0...5) = "begin"
├── @ BeginNode (location: (1,0)-(5,3))
│ ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (6...7))
│ │ @ StatementsNode (location: (2,0)-(2,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (6...7))
│ │ └── @ CallNode (location: (2,0)-(2,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (6...7) = "a"
│ │ ├── message_loc: (2,0)-(2,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -21,32 +21,32 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (8...20))
│ │ ├── ensure_keyword_loc: (8...14) = "ensure"
│ │ @ EnsureNode (location: (3,0)-(5,3))
│ │ ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (15...16))
│ │ │ @ StatementsNode (location: (4,0)-(4,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (15...16))
│ │ │ └── @ CallNode (location: (4,0)-(4,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (15...16) = "b"
│ │ │ ├── message_loc: (4,0)-(4,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── end_keyword_loc: (17...20) = "end"
│ └── end_keyword_loc: (17...20) = "end"
├── @ BeginNode (location: (22...46))
│ ├── begin_keyword_loc: (22...27) = "begin"
│ │ └── end_keyword_loc: (5,0)-(5,3) = "end"
│ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ BeginNode (location: (7,0)-(7,24))
│ ├── begin_keyword_loc: (7,0)-(7,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (29...30))
│ │ @ StatementsNode (location: (7,7)-(7,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (29...30))
│ │ └── @ CallNode (location: (7,7)-(7,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (29...30) = "a"
│ │ ├── message_loc: (7,7)-(7,8) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -56,32 +56,32 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (32...46))
│ │ ├── ensure_keyword_loc: (32...38) = "ensure"
│ │ @ EnsureNode (location: (7,10)-(7,24))
│ │ ├── ensure_keyword_loc: (7,10)-(7,16) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (40...41))
│ │ │ @ StatementsNode (location: (7,18)-(7,19))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (40...41))
│ │ │ └── @ CallNode (location: (7,18)-(7,19))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (40...41) = "b"
│ │ │ ├── message_loc: (7,18)-(7,19) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── end_keyword_loc: (43...46) = "end"
│ └── end_keyword_loc: (43...46) = "end"
├── @ BeginNode (location: (48...70))
│ ├── begin_keyword_loc: (48...53) = "begin"
│ │ └── end_keyword_loc: (7,21)-(7,24) = "end"
│ └── end_keyword_loc: (7,21)-(7,24) = "end"
├── @ BeginNode (location: (9,0)-(11,4))
│ ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (54...55))
│ │ @ StatementsNode (location: (9,6)-(9,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (54...55))
│ │ └── @ CallNode (location: (9,6)-(9,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (54...55) = "a"
│ │ ├── message_loc: (9,6)-(9,7) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -91,32 +91,32 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (57...70))
│ │ ├── ensure_keyword_loc: (57...63) = "ensure"
│ │ @ EnsureNode (location: (10,1)-(11,4))
│ │ ├── ensure_keyword_loc: (10,1)-(10,7) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (64...65))
│ │ │ @ StatementsNode (location: (10,8)-(10,9))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (64...65))
│ │ │ └── @ CallNode (location: (10,8)-(10,9))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (64...65) = "b"
│ │ │ ├── message_loc: (10,8)-(10,9) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── end_keyword_loc: (67...70) = "end"
│ └── end_keyword_loc: (67...70) = "end"
├── @ BeginNode (location: (72...94))
│ ├── begin_keyword_loc: (72...77) = "begin"
│ │ └── end_keyword_loc: (11,1)-(11,4) = "end"
│ └── end_keyword_loc: (11,1)-(11,4) = "end"
├── @ BeginNode (location: (13,0)-(13,22))
│ ├── begin_keyword_loc: (13,0)-(13,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (78...79))
│ │ @ StatementsNode (location: (13,6)-(13,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (78...79))
│ │ └── @ CallNode (location: (13,6)-(13,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (78...79) = "a"
│ │ ├── message_loc: (13,6)-(13,7) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -126,115 +126,115 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (81...94))
│ │ ├── ensure_keyword_loc: (81...87) = "ensure"
│ │ @ EnsureNode (location: (13,9)-(13,22))
│ │ ├── ensure_keyword_loc: (13,9)-(13,15) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (88...89))
│ │ │ @ StatementsNode (location: (13,16)-(13,17))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (88...89))
│ │ │ └── @ CallNode (location: (13,16)-(13,17))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (88...89) = "b"
│ │ │ ├── message_loc: (13,16)-(13,17) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── end_keyword_loc: (91...94) = "end"
│ └── end_keyword_loc: (91...94) = "end"
└── @ BeginNode (location: (96...211))
├── begin_keyword_loc: (96...101) = "begin"
│ │ └── end_keyword_loc: (13,19)-(13,22) = "end"
│ └── end_keyword_loc: (13,19)-(13,22) = "end"
└── @ BeginNode (location: (15,0)-(21,15))
├── begin_keyword_loc: (15,0)-(15,5) = "begin"
├── statements:
│ @ StatementsNode (location: (102...207))
│ @ StatementsNode (location: (15,6)-(21,11))
│ └── body: (length: 1)
│ └── @ BeginNode (location: (102...207))
│ ├── begin_keyword_loc: (102...107) = "begin"
│ └── @ BeginNode (location: (15,6)-(21,11))
│ ├── begin_keyword_loc: (15,6)-(15,11) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (107...203))
│ │ @ StatementsNode (location: (15,11)-(21,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (107...203))
│ │ └── @ CallNode (location: (15,11)-(21,7))
│ │ ├── receiver:
│ │ │ @ SymbolNode (location: (107...109))
│ │ │ ├── opening_loc: (107...108) = ":"
│ │ │ ├── value_loc: (108...109) = "s"
│ │ │ @ SymbolNode (location: (15,11)-(15,13))
│ │ │ ├── opening_loc: (15,11)-(15,12) = ":"
│ │ │ ├── value_loc: (15,12)-(15,13) = "s"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "s"
│ │ ├── call_operator_loc: (109...110) = "."
│ │ ├── message_loc: (110...111) = "l"
│ │ ├── call_operator_loc: (15,13)-(15,14) = "."
│ │ ├── message_loc: (15,14)-(15,15) = "l"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (112...203))
│ │ │ @ ArgumentsNode (location: (15,16)-(21,7))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ BeginNode (location: (112...203))
│ │ │ ├── begin_keyword_loc: (112...117) = "begin"
│ │ │ └── @ BeginNode (location: (15,16)-(21,7))
│ │ │ ├── begin_keyword_loc: (15,16)-(15,21) = "begin"
│ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: ∅
│ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (118...203))
│ │ │ │ ├── ensure_keyword_loc: (118...124) = "ensure"
│ │ │ │ @ EnsureNode (location: (15,22)-(21,7))
│ │ │ │ ├── ensure_keyword_loc: (15,22)-(15,28) = "ensure"
│ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (125...199))
│ │ │ │ │ @ StatementsNode (location: (15,29)-(21,3))
│ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (125...199))
│ │ │ │ │ └── @ CallNode (location: (15,29)-(21,3))
│ │ │ │ │ ├── receiver:
│ │ │ │ │ │ @ ConstantReadNode (location: (125...131))
│ │ │ │ │ │ @ ConstantReadNode (location: (15,29)-(15,35))
│ │ │ │ │ │ └── name: :Module
│ │ │ │ │ ├── call_operator_loc: (131...132) = "."
│ │ │ │ │ ├── message_loc: (132...135) = "new"
│ │ │ │ │ ├── call_operator_loc: (15,35)-(15,36) = "."
│ │ │ │ │ ├── message_loc: (15,36)-(15,39) = "new"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block:
│ │ │ │ │ │ @ BlockNode (location: (136...199))
│ │ │ │ │ │ @ BlockNode (location: (15,40)-(21,3))
│ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ ├── body:
│ │ │ │ │ │ │ @ StatementsNode (location: (141...195))
│ │ │ │ │ │ │ @ StatementsNode (location: (16,2)-(20,5))
│ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ └── @ BeginNode (location: (141...195))
│ │ │ │ │ │ │ ├── begin_keyword_loc: (141...146) = "begin"
│ │ │ │ │ │ │ └── @ BeginNode (location: (16,2)-(20,5))
│ │ │ │ │ │ │ ├── begin_keyword_loc: (16,2)-(16,7) = "begin"
│ │ │ │ │ │ │ ├── statements:
│ │ │ │ │ │ │ │ @ StatementsNode (location: (151...156))
│ │ │ │ │ │ │ │ @ StatementsNode (location: (17,4)-(17,9))
│ │ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ │ └── @ BreakNode (location: (151...156))
│ │ │ │ │ │ │ │ └── @ BreakNode (location: (17,4)-(17,9))
│ │ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ │ │ └── keyword_loc: (151...156) = "break"
│ │ │ │ │ │ │ │ └── keyword_loc: (17,4)-(17,9) = "break"
│ │ │ │ │ │ │ ├── rescue_clause: ∅
│ │ │ │ │ │ │ ├── else_clause: ∅
│ │ │ │ │ │ │ ├── ensure_clause:
│ │ │ │ │ │ │ │ @ EnsureNode (location: (161...195))
│ │ │ │ │ │ │ │ ├── ensure_keyword_loc: (161...167) = "ensure"
│ │ │ │ │ │ │ │ @ EnsureNode (location: (18,4)-(20,5))
│ │ │ │ │ │ │ │ ├── ensure_keyword_loc: (18,4)-(18,10) = "ensure"
│ │ │ │ │ │ │ │ ├── statements:
│ │ │ │ │ │ │ │ │ @ StatementsNode (location: (168...189))
│ │ │ │ │ │ │ │ │ @ StatementsNode (location: (18,11)-(19,7))
│ │ │ │ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ │ │ │ └── @ CallNode (location: (168...189))
│ │ │ │ │ │ │ │ │ └── @ CallNode (location: (18,11)-(19,7))
│ │ │ │ │ │ │ │ │ ├── receiver:
│ │ │ │ │ │ │ │ │ │ @ ConstantReadNode (location: (168...174))
│ │ │ │ │ │ │ │ │ │ @ ConstantReadNode (location: (18,11)-(18,17))
│ │ │ │ │ │ │ │ │ │ └── name: :Module
│ │ │ │ │ │ │ │ │ ├── call_operator_loc: (174...175) = "."
│ │ │ │ │ │ │ │ │ ├── message_loc: (175...178) = "new"
│ │ │ │ │ │ │ │ │ ├── call_operator_loc: (18,17)-(18,18) = "."
│ │ │ │ │ │ │ │ │ ├── message_loc: (18,18)-(18,21) = "new"
│ │ │ │ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ │ │ │ ├── block:
│ │ │ │ │ │ │ │ │ │ @ BlockNode (location: (179...189))
│ │ │ │ │ │ │ │ │ │ @ BlockNode (location: (18,22)-(19,7))
│ │ │ │ │ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ │ │ │ │ ├── body: ∅
│ │ │ │ │ │ │ │ │ │ ├── opening_loc: (179...181) = "do"
│ │ │ │ │ │ │ │ │ │ └── closing_loc: (186...189) = "end"
│ │ │ │ │ │ │ │ │ │ ├── opening_loc: (18,22)-(18,24) = "do"
│ │ │ │ │ │ │ │ │ │ └── closing_loc: (19,4)-(19,7) = "end"
│ │ │ │ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ │ │ │ │ └── name: "new"
│ │ │ │ │ │ │ │ └── end_keyword_loc: (192...195) = "end"
│ │ │ │ │ │ │ └── end_keyword_loc: (192...195) = "end"
│ │ │ │ │ │ ├── opening_loc: (136...138) = "do"
│ │ │ │ │ │ └── closing_loc: (196...199) = "end"
│ │ │ │ │ │ │ │ └── end_keyword_loc: (20,2)-(20,5) = "end"
│ │ │ │ │ │ │ └── end_keyword_loc: (20,2)-(20,5) = "end"
│ │ │ │ │ │ ├── opening_loc: (15,40)-(15,42) = "do"
│ │ │ │ │ │ └── closing_loc: (21,0)-(21,3) = "end"
│ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "new"
│ │ │ │ └── end_keyword_loc: (200...203) = "end"
│ │ │ └── end_keyword_loc: (200...203) = "end"
│ │ │ │ └── end_keyword_loc: (21,4)-(21,7) = "end"
│ │ │ └── end_keyword_loc: (21,4)-(21,7) = "end"
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
@ -242,8 +242,8 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (204...207) = "end"
│ └── end_keyword_loc: (21,8)-(21,11) = "end"
├── rescue_clause: ∅
├── else_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]
└── statements:
@ StatementsNode (location: (0...578))
@ StatementsNode (location: (1,0)-(78,3))
└── body: (length: 17)
├── @ BeginNode (location: (0...33))
│ ├── begin_keyword_loc: (0...5) = "begin"
├── @ BeginNode (location: (1,0)-(1,33))
│ ├── begin_keyword_loc: (1,0)-(1,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (7...8))
│ │ @ StatementsNode (location: (1,7)-(1,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (7...8))
│ │ └── @ CallNode (location: (1,7)-(1,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (7...8) = "a"
│ │ ├── message_loc: (1,7)-(1,8) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -19,18 +19,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (10...19))
│ │ ├── keyword_loc: (10...16) = "rescue"
│ │ @ RescueNode (location: (1,10)-(1,19))
│ │ ├── keyword_loc: (1,10)-(1,16) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (18...19))
│ │ │ @ StatementsNode (location: (1,18)-(1,19))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (18...19))
│ │ │ └── @ CallNode (location: (1,18)-(1,19))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (18...19) = "b"
│ │ │ ├── message_loc: (1,18)-(1,19) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -39,33 +39,33 @@
│ │ │ └── name: "b"
│ │ └── consequent: ∅
│ ├── else_clause:
│ │ @ ElseNode (location: (21...33))
│ │ ├── else_keyword_loc: (21...25) = "else"
│ │ @ ElseNode (location: (1,21)-(1,33))
│ │ ├── else_keyword_loc: (1,21)-(1,25) = "else"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (27...28))
│ │ │ @ StatementsNode (location: (1,27)-(1,28))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (27...28))
│ │ │ └── @ CallNode (location: (1,27)-(1,28))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (27...28) = "c"
│ │ │ ├── message_loc: (1,27)-(1,28) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "c"
│ │ └── end_keyword_loc: (30...33) = "end"
│ │ └── end_keyword_loc: (1,30)-(1,33) = "end"
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (30...33) = "end"
├── @ BeginNode (location: (35...79))
│ ├── begin_keyword_loc: (35...40) = "begin"
│ └── end_keyword_loc: (1,30)-(1,33) = "end"
├── @ BeginNode (location: (3,0)-(3,44))
│ ├── begin_keyword_loc: (3,0)-(3,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (42...43))
│ │ @ StatementsNode (location: (3,7)-(3,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (42...43))
│ │ └── @ CallNode (location: (3,7)-(3,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (42...43) = "a"
│ │ ├── message_loc: (3,7)-(3,8) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -73,18 +73,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (45...54))
│ │ ├── keyword_loc: (45...51) = "rescue"
│ │ @ RescueNode (location: (3,10)-(3,19))
│ │ ├── keyword_loc: (3,10)-(3,16) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (53...54))
│ │ │ @ StatementsNode (location: (3,18)-(3,19))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (53...54))
│ │ │ └── @ CallNode (location: (3,18)-(3,19))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (53...54) = "b"
│ │ │ ├── message_loc: (3,18)-(3,19) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -93,49 +93,49 @@
│ │ │ └── name: "b"
│ │ └── consequent: ∅
│ ├── else_clause:
│ │ @ ElseNode (location: (56...71))
│ │ ├── else_keyword_loc: (56...60) = "else"
│ │ @ ElseNode (location: (3,21)-(3,36))
│ │ ├── else_keyword_loc: (3,21)-(3,25) = "else"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (62...63))
│ │ │ @ StatementsNode (location: (3,27)-(3,28))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (62...63))
│ │ │ └── @ CallNode (location: (3,27)-(3,28))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (62...63) = "c"
│ │ │ ├── message_loc: (3,27)-(3,28) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "c"
│ │ └── end_keyword_loc: (65...71) = "ensure"
│ │ └── end_keyword_loc: (3,30)-(3,36) = "ensure"
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (65...79))
│ │ ├── ensure_keyword_loc: (65...71) = "ensure"
│ │ @ EnsureNode (location: (3,30)-(3,44))
│ │ ├── ensure_keyword_loc: (3,30)-(3,36) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (73...74))
│ │ │ @ StatementsNode (location: (3,38)-(3,39))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (73...74))
│ │ │ └── @ CallNode (location: (3,38)-(3,39))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (73...74) = "d"
│ │ │ ├── message_loc: (3,38)-(3,39) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ └── end_keyword_loc: (76...79) = "end"
│ └── end_keyword_loc: (76...79) = "end"
├── @ BeginNode (location: (81...92))
│ ├── begin_keyword_loc: (81...86) = "begin"
│ │ └── end_keyword_loc: (3,41)-(3,44) = "end"
│ └── end_keyword_loc: (3,41)-(3,44) = "end"
├── @ BeginNode (location: (5,0)-(7,3))
│ ├── begin_keyword_loc: (5,0)-(5,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (87...88))
│ │ @ StatementsNode (location: (6,0)-(6,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (87...88))
│ │ └── @ CallNode (location: (6,0)-(6,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (87...88) = "a"
│ │ ├── message_loc: (6,0)-(6,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -145,16 +145,16 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (89...92) = "end"
├── @ BeginNode (location: (94...107))
│ ├── begin_keyword_loc: (94...99) = "begin"
│ └── end_keyword_loc: (7,0)-(7,3) = "end"
├── @ BeginNode (location: (9,0)-(9,13))
│ ├── begin_keyword_loc: (9,0)-(9,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (101...102))
│ │ @ StatementsNode (location: (9,7)-(9,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (101...102))
│ │ └── @ CallNode (location: (9,7)-(9,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (101...102) = "a"
│ │ ├── message_loc: (9,7)-(9,8) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -164,16 +164,16 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (104...107) = "end"
├── @ BeginNode (location: (109...121))
│ ├── begin_keyword_loc: (109...114) = "begin"
│ └── end_keyword_loc: (9,10)-(9,13) = "end"
├── @ BeginNode (location: (11,0)-(12,4))
│ ├── begin_keyword_loc: (11,0)-(11,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (115...116))
│ │ @ StatementsNode (location: (11,6)-(11,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (115...116))
│ │ └── @ CallNode (location: (11,6)-(11,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (115...116) = "a"
│ │ ├── message_loc: (11,6)-(11,7) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -183,16 +183,16 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (118...121) = "end"
├── @ BeginNode (location: (123...135))
│ ├── begin_keyword_loc: (123...128) = "begin"
│ └── end_keyword_loc: (12,1)-(12,4) = "end"
├── @ BeginNode (location: (14,0)-(14,12))
│ ├── begin_keyword_loc: (14,0)-(14,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (129...130))
│ │ @ StatementsNode (location: (14,6)-(14,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (129...130))
│ │ └── @ CallNode (location: (14,6)-(14,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (129...130) = "a"
│ │ ├── message_loc: (14,6)-(14,7) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -202,16 +202,16 @@
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (132...135) = "end"
├── @ BeginNode (location: (137...175))
│ ├── begin_keyword_loc: (137...142) = "begin"
│ └── end_keyword_loc: (14,9)-(14,12) = "end"
├── @ BeginNode (location: (16,0)-(24,3))
│ ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (143...144))
│ │ @ StatementsNode (location: (17,0)-(17,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (143...144))
│ │ └── @ CallNode (location: (17,0)-(17,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (143...144) = "a"
│ │ ├── message_loc: (17,0)-(17,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -219,18 +219,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (145...171))
│ │ ├── keyword_loc: (145...151) = "rescue"
│ │ @ RescueNode (location: (18,0)-(23,1))
│ │ ├── keyword_loc: (18,0)-(18,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (152...153))
│ │ │ @ StatementsNode (location: (19,0)-(19,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (152...153))
│ │ │ └── @ CallNode (location: (19,0)-(19,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (152...153) = "b"
│ │ │ ├── message_loc: (19,0)-(19,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -238,18 +238,18 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── consequent:
│ │ @ RescueNode (location: (154...171))
│ │ ├── keyword_loc: (154...160) = "rescue"
│ │ @ RescueNode (location: (20,0)-(23,1))
│ │ ├── keyword_loc: (20,0)-(20,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (161...162))
│ │ │ @ StatementsNode (location: (21,0)-(21,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (161...162))
│ │ │ └── @ CallNode (location: (21,0)-(21,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (161...162) = "c"
│ │ │ ├── message_loc: (21,0)-(21,1) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -257,18 +257,18 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "c"
│ │ └── consequent:
│ │ @ RescueNode (location: (163...171))
│ │ ├── keyword_loc: (163...169) = "rescue"
│ │ @ RescueNode (location: (22,0)-(23,1))
│ │ ├── keyword_loc: (22,0)-(22,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (170...171))
│ │ │ @ StatementsNode (location: (23,0)-(23,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (170...171))
│ │ │ └── @ CallNode (location: (23,0)-(23,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (170...171) = "d"
│ │ │ ├── message_loc: (23,0)-(23,1) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -278,16 +278,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (172...175) = "end"
├── @ BeginNode (location: (177...269))
│ ├── begin_keyword_loc: (177...182) = "begin"
│ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ BeginNode (location: (26,0)-(32,3))
│ ├── begin_keyword_loc: (26,0)-(26,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (185...186))
│ │ @ StatementsNode (location: (27,2)-(27,3))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (185...186))
│ │ └── @ CallNode (location: (27,2)-(27,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (185...186) = "a"
│ │ ├── message_loc: (27,2)-(27,3) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -295,23 +295,23 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (187...265))
│ │ ├── keyword_loc: (187...193) = "rescue"
│ │ @ RescueNode (location: (28,0)-(31,3))
│ │ ├── keyword_loc: (28,0)-(28,6) = "rescue"
│ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (194...203))
│ │ │ └── @ ConstantReadNode (location: (28,7)-(28,16))
│ │ │ └── name: :Exception
│ │ ├── operator_loc: (204...206) = "=>"
│ │ ├── operator_loc: (28,17)-(28,19) = "=>"
│ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (207...209))
│ │ │ @ LocalVariableTargetNode (location: (28,20)-(28,22))
│ │ │ ├── name: :ex
│ │ │ └── depth: 0
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (212...213))
│ │ │ @ StatementsNode (location: (29,2)-(29,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (212...213))
│ │ │ └── @ CallNode (location: (29,2)-(29,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (212...213) = "b"
│ │ │ ├── message_loc: (29,2)-(29,3) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -319,25 +319,25 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── consequent:
│ │ @ RescueNode (location: (214...265))
│ │ ├── keyword_loc: (214...220) = "rescue"
│ │ @ RescueNode (location: (30,0)-(31,3))
│ │ ├── keyword_loc: (30,0)-(30,6) = "rescue"
│ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (221...237))
│ │ │ ├── @ ConstantReadNode (location: (30,7)-(30,23))
│ │ │ │ └── name: :AnotherException
│ │ │ └── @ ConstantReadNode (location: (239...255))
│ │ │ └── @ ConstantReadNode (location: (30,25)-(30,41))
│ │ │ └── name: :OneMoreException
│ │ ├── operator_loc: (256...258) = "=>"
│ │ ├── operator_loc: (30,42)-(30,44) = "=>"
│ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (259...261))
│ │ │ @ LocalVariableTargetNode (location: (30,45)-(30,47))
│ │ │ ├── name: :ex
│ │ │ └── depth: 0
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (264...265))
│ │ │ @ StatementsNode (location: (31,2)-(31,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (264...265))
│ │ │ └── @ CallNode (location: (31,2)-(31,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (264...265) = "c"
│ │ │ ├── message_loc: (31,2)-(31,3) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -347,16 +347,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (266...269) = "end"
├── @ BeginNode (location: (271...322))
│ ├── begin_keyword_loc: (271...276) = "begin"
│ └── end_keyword_loc: (32,0)-(32,3) = "end"
├── @ BeginNode (location: (34,0)-(40,3))
│ ├── begin_keyword_loc: (34,0)-(34,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (279...280))
│ │ @ StatementsNode (location: (35,2)-(35,3))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (279...280))
│ │ └── @ CallNode (location: (35,2)-(35,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (279...280) = "a"
│ │ ├── message_loc: (35,2)-(35,3) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -364,23 +364,23 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (281...307))
│ │ ├── keyword_loc: (281...287) = "rescue"
│ │ @ RescueNode (location: (36,0)-(37,3))
│ │ ├── keyword_loc: (36,0)-(36,6) = "rescue"
│ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (288...297))
│ │ │ └── @ ConstantReadNode (location: (36,7)-(36,16))
│ │ │ └── name: :Exception
│ │ ├── operator_loc: (298...300) = "=>"
│ │ ├── operator_loc: (36,17)-(36,19) = "=>"
│ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (301...303))
│ │ │ @ LocalVariableTargetNode (location: (36,20)-(36,22))
│ │ │ ├── name: :ex
│ │ │ └── depth: 0
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (306...307))
│ │ │ @ StatementsNode (location: (37,2)-(37,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (306...307))
│ │ │ └── @ CallNode (location: (37,2)-(37,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (306...307) = "b"
│ │ │ ├── message_loc: (37,2)-(37,3) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -390,38 +390,38 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (308...322))
│ │ ├── ensure_keyword_loc: (308...314) = "ensure"
│ │ @ EnsureNode (location: (38,0)-(40,3))
│ │ ├── ensure_keyword_loc: (38,0)-(38,6) = "ensure"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (317...318))
│ │ │ @ StatementsNode (location: (39,2)-(39,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (317...318))
│ │ │ └── @ CallNode (location: (39,2)-(39,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (317...318) = "b"
│ │ │ ├── message_loc: (39,2)-(39,3) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ └── end_keyword_loc: (319...322) = "end"
│ └── end_keyword_loc: (319...322) = "end"
├── @ StringNode (location: (324...330))
│ │ └── end_keyword_loc: (40,0)-(40,3) = "end"
│ └── end_keyword_loc: (40,0)-(40,3) = "end"
├── @ StringNode (location: (42,0)-(42,6))
│ ├── flags: ∅
│ ├── opening_loc: (324...326) = "%!"
│ ├── content_loc: (326...329) = "abc"
│ ├── closing_loc: (329...330) = "!"
│ ├── opening_loc: (42,0)-(42,2) = "%!"
│ ├── content_loc: (42,2)-(42,5) = "abc"
│ ├── closing_loc: (42,5)-(42,6) = "!"
│ └── unescaped: "abc"
├── @ BeginNode (location: (332...352))
│ ├── begin_keyword_loc: (332...337) = "begin"
├── @ BeginNode (location: (44,0)-(48,3))
│ ├── begin_keyword_loc: (44,0)-(44,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (338...339))
│ │ @ StatementsNode (location: (45,0)-(45,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (338...339))
│ │ └── @ CallNode (location: (45,0)-(45,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (338...339) = "a"
│ │ ├── message_loc: (45,0)-(45,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -429,18 +429,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (340...348))
│ │ ├── keyword_loc: (340...346) = "rescue"
│ │ @ RescueNode (location: (46,0)-(47,1))
│ │ ├── keyword_loc: (46,0)-(46,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (347...348))
│ │ │ @ StatementsNode (location: (47,0)-(47,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (347...348))
│ │ │ └── @ CallNode (location: (47,0)-(47,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (347...348) = "b"
│ │ │ ├── message_loc: (47,0)-(47,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -450,16 +450,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (349...352) = "end"
├── @ BeginNode (location: (354...374))
│ ├── begin_keyword_loc: (354...359) = "begin"
│ └── end_keyword_loc: (48,0)-(48,3) = "end"
├── @ BeginNode (location: (50,0)-(50,20))
│ ├── begin_keyword_loc: (50,0)-(50,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (360...361))
│ │ @ StatementsNode (location: (50,6)-(50,7))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (360...361))
│ │ └── @ CallNode (location: (50,6)-(50,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (360...361) = "a"
│ │ ├── message_loc: (50,6)-(50,7) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -467,18 +467,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (362...370))
│ │ ├── keyword_loc: (362...368) = "rescue"
│ │ @ RescueNode (location: (50,8)-(50,16))
│ │ ├── keyword_loc: (50,8)-(50,14) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (369...370))
│ │ │ @ StatementsNode (location: (50,15)-(50,16))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (369...370))
│ │ │ └── @ CallNode (location: (50,15)-(50,16))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (369...370) = "b"
│ │ │ ├── message_loc: (50,15)-(50,16) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -488,16 +488,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (371...374) = "end"
├── @ BeginNode (location: (376...396))
│ ├── begin_keyword_loc: (376...381) = "begin"
│ └── end_keyword_loc: (50,17)-(50,20) = "end"
├── @ BeginNode (location: (52,0)-(54,5))
│ ├── begin_keyword_loc: (52,0)-(52,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (382...383))
│ │ @ StatementsNode (location: (53,0)-(53,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (382...383))
│ │ └── @ CallNode (location: (53,0)-(53,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (382...383) = "a"
│ │ ├── message_loc: (53,0)-(53,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -505,18 +505,18 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (384...392))
│ │ ├── keyword_loc: (384...390) = "rescue"
│ │ @ RescueNode (location: (53,2)-(54,1))
│ │ ├── keyword_loc: (53,2)-(53,8) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (391...392))
│ │ │ @ StatementsNode (location: (54,0)-(54,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (391...392))
│ │ │ └── @ CallNode (location: (54,0)-(54,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (391...392) = "b"
│ │ │ ├── message_loc: (54,0)-(54,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -526,16 +526,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (393...396) = "end"
├── @ BeginNode (location: (398...428))
│ ├── begin_keyword_loc: (398...403) = "begin"
│ └── end_keyword_loc: (54,2)-(54,5) = "end"
├── @ BeginNode (location: (56,0)-(60,3))
│ ├── begin_keyword_loc: (56,0)-(56,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (404...405))
│ │ @ StatementsNode (location: (57,0)-(57,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (404...405))
│ │ └── @ CallNode (location: (57,0)-(57,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (404...405) = "a"
│ │ ├── message_loc: (57,0)-(57,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -543,20 +543,20 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (406...424))
│ │ ├── keyword_loc: (406...412) = "rescue"
│ │ @ RescueNode (location: (58,0)-(59,1))
│ │ ├── keyword_loc: (58,0)-(58,6) = "rescue"
│ │ ├── exceptions: (length: 1)
│ │ │ └── @ ConstantReadNode (location: (413...422))
│ │ │ └── @ ConstantReadNode (location: (58,7)-(58,16))
│ │ │ └── name: :Exception
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (423...424))
│ │ │ @ StatementsNode (location: (59,0)-(59,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (423...424))
│ │ │ └── @ CallNode (location: (59,0)-(59,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (423...424) = "b"
│ │ │ ├── message_loc: (59,0)-(59,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -566,16 +566,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (425...428) = "end"
├── @ BeginNode (location: (430...477))
│ ├── begin_keyword_loc: (430...435) = "begin"
│ └── end_keyword_loc: (60,0)-(60,3) = "end"
├── @ BeginNode (location: (62,0)-(66,3))
│ ├── begin_keyword_loc: (62,0)-(62,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (436...437))
│ │ @ StatementsNode (location: (63,0)-(63,1))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (436...437))
│ │ └── @ CallNode (location: (63,0)-(63,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (436...437) = "a"
│ │ ├── message_loc: (63,0)-(63,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -583,22 +583,22 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (438...473))
│ │ ├── keyword_loc: (438...444) = "rescue"
│ │ @ RescueNode (location: (64,0)-(65,1))
│ │ ├── keyword_loc: (64,0)-(64,6) = "rescue"
│ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (445...454))
│ │ │ ├── @ ConstantReadNode (location: (64,7)-(64,16))
│ │ │ │ └── name: :Exception
│ │ │ └── @ ConstantReadNode (location: (456...471))
│ │ │ └── @ ConstantReadNode (location: (64,18)-(64,33))
│ │ │ └── name: :CustomException
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (472...473))
│ │ │ @ StatementsNode (location: (65,0)-(65,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (472...473))
│ │ │ └── @ CallNode (location: (65,0)-(65,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (472...473) = "b"
│ │ │ ├── message_loc: (65,0)-(65,1) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -608,16 +608,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (474...477) = "end"
├── @ BeginNode (location: (479...536))
│ ├── begin_keyword_loc: (479...484) = "begin"
│ └── end_keyword_loc: (66,0)-(66,3) = "end"
├── @ BeginNode (location: (68,0)-(72,3))
│ ├── begin_keyword_loc: (68,0)-(68,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (487...488))
│ │ @ StatementsNode (location: (69,2)-(69,3))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (487...488))
│ │ └── @ CallNode (location: (69,2)-(69,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (487...488) = "a"
│ │ ├── message_loc: (69,2)-(69,3) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -625,25 +625,25 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (489...532))
│ │ ├── keyword_loc: (489...495) = "rescue"
│ │ @ RescueNode (location: (70,0)-(71,3))
│ │ ├── keyword_loc: (70,0)-(70,6) = "rescue"
│ │ ├── exceptions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (496...505))
│ │ │ ├── @ ConstantReadNode (location: (70,7)-(70,16))
│ │ │ │ └── name: :Exception
│ │ │ └── @ ConstantReadNode (location: (507...522))
│ │ │ └── @ ConstantReadNode (location: (70,18)-(70,33))
│ │ │ └── name: :CustomException
│ │ ├── operator_loc: (523...525) = "=>"
│ │ ├── operator_loc: (70,34)-(70,36) = "=>"
│ │ ├── reference:
│ │ │ @ LocalVariableTargetNode (location: (526...528))
│ │ │ @ LocalVariableTargetNode (location: (70,37)-(70,39))
│ │ │ ├── name: :ex
│ │ │ └── depth: 0
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (531...532))
│ │ │ @ StatementsNode (location: (71,2)-(71,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (531...532))
│ │ │ └── @ CallNode (location: (71,2)-(71,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (531...532) = "b"
│ │ │ ├── message_loc: (71,2)-(71,3) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -653,16 +653,16 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (533...536) = "end"
└── @ BeginNode (location: (538...578))
├── begin_keyword_loc: (538...543) = "begin"
│ └── end_keyword_loc: (72,0)-(72,3) = "end"
└── @ BeginNode (location: (74,0)-(78,3))
├── begin_keyword_loc: (74,0)-(74,5) = "begin"
├── statements:
│ @ StatementsNode (location: (546...547))
│ @ StatementsNode (location: (75,2)-(75,3))
│ └── body: (length: 1)
│ └── @ CallNode (location: (546...547))
│ └── @ CallNode (location: (75,2)-(75,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (546...547) = "a"
│ ├── message_loc: (75,2)-(75,3) = "a"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
@ -670,23 +670,23 @@
│ ├── flags: variable_call
│ └── name: "a"
├── rescue_clause:
│ @ RescueNode (location: (548...574))
│ ├── keyword_loc: (548...554) = "rescue"
│ @ RescueNode (location: (76,0)-(77,3))
│ ├── keyword_loc: (76,0)-(76,6) = "rescue"
│ ├── exceptions: (length: 1)
│ │ └── @ ConstantReadNode (location: (555...564))
│ │ └── @ ConstantReadNode (location: (76,7)-(76,16))
│ │ └── name: :Exception
│ ├── operator_loc: (565...567) = "=>"
│ ├── operator_loc: (76,17)-(76,19) = "=>"
│ ├── reference:
│ │ @ LocalVariableTargetNode (location: (568...570))
│ │ @ LocalVariableTargetNode (location: (76,20)-(76,22))
│ │ ├── name: :ex
│ │ └── depth: 0
│ ├── statements:
│ │ @ StatementsNode (location: (573...574))
│ │ @ StatementsNode (location: (77,2)-(77,3))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (573...574))
│ │ └── @ CallNode (location: (77,2)-(77,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (573...574) = "b"
│ │ ├── message_loc: (77,2)-(77,3) = "b"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -696,4 +696,4 @@
│ └── consequent: ∅
├── else_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]
└── statements:
@ StatementsNode (location: (0...402))
@ StatementsNode (location: (1,0)-(54,17))
└── body: (length: 20)
├── @ CallNode (location: (0...16))
├── @ CallNode (location: (1,0)-(1,16))
│ ├── receiver:
│ │ @ CallNode (location: (0...3))
│ │ @ CallNode (location: (1,0)-(1,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "foo"
│ │ ├── message_loc: (1,0)-(1,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -16,49 +16,49 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (3...8) = "[bar]"
│ ├── opening_loc: (3...4) = "["
│ ├── message_loc: (1,3)-(1,8) = "[bar]"
│ ├── opening_loc: (1,3)-(1,4) = "["
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7))
│ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7))
│ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...7) = "bar"
│ │ ├── message_loc: (1,4)-(1,7) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "bar"
│ ├── closing_loc: (7...8) = "]"
│ ├── closing_loc: (1,7)-(1,8) = "]"
│ ├── block:
│ │ @ BlockNode (location: (9...16))
│ │ @ BlockNode (location: (1,9)-(1,16))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (11...14))
│ │ │ @ StatementsNode (location: (1,11)-(1,14))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...14))
│ │ │ └── @ CallNode (location: (1,11)-(1,14))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...14) = "baz"
│ │ │ ├── message_loc: (1,11)-(1,14) = "baz"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "baz"
│ │ ├── opening_loc: (9...10) = "{"
│ │ └── closing_loc: (15...16) = "}"
│ │ ├── opening_loc: (1,9)-(1,10) = "{"
│ │ └── closing_loc: (1,15)-(1,16) = "}"
│ ├── flags: ∅
│ └── name: "[]"
├── @ CallNode (location: (18...37))
├── @ CallNode (location: (3,0)-(5,3))
│ ├── receiver:
│ │ @ CallNode (location: (18...21))
│ │ @ CallNode (location: (3,0)-(3,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (18...21) = "foo"
│ │ ├── message_loc: (3,0)-(3,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -66,75 +66,75 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (21...26) = "[bar]"
│ ├── opening_loc: (21...22) = "["
│ ├── message_loc: (3,3)-(3,8) = "[bar]"
│ ├── opening_loc: (3,3)-(3,4) = "["
│ ├── arguments:
│ │ @ ArgumentsNode (location: (22...25))
│ │ @ ArgumentsNode (location: (3,4)-(3,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (22...25))
│ │ └── @ CallNode (location: (3,4)-(3,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (22...25) = "bar"
│ │ ├── message_loc: (3,4)-(3,7) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "bar"
│ ├── closing_loc: (25...26) = "]"
│ ├── closing_loc: (3,7)-(3,8) = "]"
│ ├── block:
│ │ @ BlockNode (location: (27...37))
│ │ @ BlockNode (location: (3,9)-(5,3))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (30...33))
│ │ │ @ StatementsNode (location: (4,0)-(4,3))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (30...33))
│ │ │ └── @ CallNode (location: (4,0)-(4,3))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (30...33) = "baz"
│ │ │ ├── message_loc: (4,0)-(4,3) = "baz"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "baz"
│ │ ├── opening_loc: (27...29) = "do"
│ │ └── closing_loc: (34...37) = "end"
│ │ ├── opening_loc: (3,9)-(3,11) = "do"
│ │ └── closing_loc: (5,0)-(5,3) = "end"
│ ├── flags: ∅
│ └── name: "[]"
├── @ CallNode (location: (39...74))
├── @ CallNode (location: (7,0)-(7,35))
│ ├── receiver:
│ │ @ CallNode (location: (39...40))
│ │ @ CallNode (location: (7,0)-(7,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (39...40) = "x"
│ │ ├── message_loc: (7,0)-(7,1) = "x"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "x"
│ ├── call_operator_loc: (40...41) = "."
│ ├── message_loc: (41...47) = "reduce"
│ ├── opening_loc: (47...48) = "("
│ ├── call_operator_loc: (7,1)-(7,2) = "."
│ ├── message_loc: (7,2)-(7,8) = "reduce"
│ ├── opening_loc: (7,8)-(7,9) = "("
│ ├── arguments:
│ │ @ ArgumentsNode (location: (48...49))
│ │ @ ArgumentsNode (location: (7,9)-(7,10))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (48...49))
│ │ └── @ IntegerNode (location: (7,9)-(7,10))
│ │ └── flags: decimal
│ ├── closing_loc: (49...50) = ")"
│ ├── closing_loc: (7,10)-(7,11) = ")"
│ ├── block:
│ │ @ BlockNode (location: (51...74))
│ │ @ BlockNode (location: (7,12)-(7,35))
│ │ ├── locals: [:x, :memo]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (53...62))
│ │ │ @ BlockParametersNode (location: (7,14)-(7,23))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (54...61))
│ │ │ │ @ ParametersNode (location: (7,15)-(7,22))
│ │ │ │ ├── requireds: (length: 2)
│ │ │ │ │ ├── @ RequiredParameterNode (location: (54...55))
│ │ │ │ │ ├── @ RequiredParameterNode (location: (7,15)-(7,16))
│ │ │ │ │ │ └── name: :x
│ │ │ │ │ └── @ RequiredParameterNode (location: (57...61))
│ │ │ │ │ └── @ RequiredParameterNode (location: (7,18)-(7,22))
│ │ │ │ │ └── name: :memo
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -143,97 +143,97 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (53...54) = "|"
│ │ │ └── closing_loc: (61...62) = "|"
│ │ │ ├── opening_loc: (7,14)-(7,15) = "|"
│ │ │ └── closing_loc: (7,22)-(7,23) = "|"
│ │ ├── body:
│ │ │ @ StatementsNode (location: (63...72))
│ │ │ @ StatementsNode (location: (7,24)-(7,33))
│ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableOperatorWriteNode (location: (63...72))
│ │ │ ├── name_loc: (63...67) = "memo"
│ │ │ ├── operator_loc: (68...70) = "+="
│ │ │ └── @ LocalVariableOperatorWriteNode (location: (7,24)-(7,33))
│ │ │ ├── name_loc: (7,24)-(7,28) = "memo"
│ │ │ ├── operator_loc: (7,29)-(7,31) = "+="
│ │ │ ├── value:
│ │ │ │ @ LocalVariableReadNode (location: (71...72))
│ │ │ │ @ LocalVariableReadNode (location: (7,32)-(7,33))
│ │ │ │ ├── name: :x
│ │ │ │ └── depth: 0
│ │ │ ├── name: :memo
│ │ │ ├── operator: :+
│ │ │ └── depth: 0
│ │ ├── opening_loc: (51...52) = "{"
│ │ └── closing_loc: (73...74) = "}"
│ │ ├── opening_loc: (7,12)-(7,13) = "{"
│ │ └── closing_loc: (7,34)-(7,35) = "}"
│ ├── flags: ∅
│ └── name: "reduce"
├── @ CallNode (location: (76...86))
├── @ CallNode (location: (9,0)-(9,10))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (76...79) = "foo"
│ ├── message_loc: (9,0)-(9,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (80...86))
│ │ @ BlockNode (location: (9,4)-(9,10))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (80...82) = "do"
│ │ └── closing_loc: (83...86) = "end"
│ │ ├── opening_loc: (9,4)-(9,6) = "do"
│ │ └── closing_loc: (9,7)-(9,10) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (88...109))
├── @ CallNode (location: (11,0)-(11,21))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (88...91) = "foo"
│ ├── message_loc: (11,0)-(11,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (92...109))
│ │ @ ArgumentsNode (location: (11,4)-(11,21))
│ │ └── arguments: (length: 2)
│ │ ├── @ CallNode (location: (92...95))
│ │ ├── @ CallNode (location: (11,4)-(11,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (92...95) = "bar"
│ │ │ ├── message_loc: (11,4)-(11,7) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ └── @ ParenthesesNode (location: (97...109))
│ │ └── @ ParenthesesNode (location: (11,9)-(11,21))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (98...108))
│ │ │ @ StatementsNode (location: (11,10)-(11,20))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (98...108))
│ │ │ └── @ CallNode (location: (11,10)-(11,20))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (98...101) = "baz"
│ │ │ ├── message_loc: (11,10)-(11,13) = "baz"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (102...108))
│ │ │ │ @ BlockNode (location: (11,14)-(11,20))
│ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (102...104) = "do"
│ │ │ │ └── closing_loc: (105...108) = "end"
│ │ │ │ ├── opening_loc: (11,14)-(11,16) = "do"
│ │ │ │ └── closing_loc: (11,17)-(11,20) = "end"
│ │ │ ├── flags: ∅
│ │ │ └── name: "baz"
│ │ ├── opening_loc: (97...98) = "("
│ │ └── closing_loc: (108...109) = ")"
│ │ ├── opening_loc: (11,9)-(11,10) = "("
│ │ └── closing_loc: (11,20)-(11,21) = ")"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (111...125))
├── @ CallNode (location: (13,0)-(13,14))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (111...114) = "foo"
│ ├── message_loc: (13,0)-(13,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (115...118))
│ │ @ ArgumentsNode (location: (13,4)-(13,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (115...118))
│ │ └── @ CallNode (location: (13,4)-(13,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (115...118) = "bar"
│ │ ├── message_loc: (13,4)-(13,7) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -242,34 +242,34 @@
│ │ └── name: "bar"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (119...125))
│ │ @ BlockNode (location: (13,8)-(13,14))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (119...121) = "do"
│ │ └── closing_loc: (122...125) = "end"
│ │ ├── opening_loc: (13,8)-(13,10) = "do"
│ │ └── closing_loc: (13,11)-(13,14) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (127...145))
├── @ CallNode (location: (15,0)-(15,18))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (127...130) = "foo"
│ ├── message_loc: (15,0)-(15,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (131...138))
│ │ @ ArgumentsNode (location: (15,4)-(15,11))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (131...138))
│ │ └── @ CallNode (location: (15,4)-(15,11))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (131...134) = "bar"
│ │ ├── message_loc: (15,4)-(15,7) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (135...138))
│ │ │ @ ArgumentsNode (location: (15,8)-(15,11))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ CallNode (location: (135...138))
│ │ │ └── @ CallNode (location: (15,8)-(15,11))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (135...138) = "baz"
│ │ │ ├── message_loc: (15,8)-(15,11) = "baz"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -282,41 +282,41 @@
│ │ └── name: "bar"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (139...145))
│ │ @ BlockNode (location: (15,12)-(15,18))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (139...141) = "do"
│ │ └── closing_loc: (142...145) = "end"
│ │ ├── opening_loc: (15,12)-(15,14) = "do"
│ │ └── closing_loc: (15,15)-(15,18) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (147...168))
├── @ CallNode (location: (17,0)-(18,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (147...150) = "foo"
│ ├── message_loc: (17,0)-(17,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (151...168))
│ │ @ BlockNode (location: (17,4)-(18,3))
│ │ ├── locals: [:a]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (154...164))
│ │ │ @ BlockParametersNode (location: (17,7)-(17,17))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (155...163))
│ │ │ │ @ ParametersNode (location: (17,8)-(17,16))
│ │ │ │ ├── requireds: (length: 0)
│ │ │ │ ├── optionals: (length: 1)
│ │ │ │ │ └── @ OptionalParameterNode (location: (155...163))
│ │ │ │ │ └── @ OptionalParameterNode (location: (17,8)-(17,16))
│ │ │ │ │ ├── name: :a
│ │ │ │ │ ├── name_loc: (155...156) = "a"
│ │ │ │ │ ├── operator_loc: (157...158) = "="
│ │ │ │ │ ├── name_loc: (17,8)-(17,9) = "a"
│ │ │ │ │ ├── operator_loc: (17,10)-(17,11) = "="
│ │ │ │ │ └── value:
│ │ │ │ │ @ CallNode (location: (159...163))
│ │ │ │ │ @ CallNode (location: (17,12)-(17,16))
│ │ │ │ │ ├── receiver:
│ │ │ │ │ │ @ CallNode (location: (159...160))
│ │ │ │ │ │ @ CallNode (location: (17,12)-(17,13))
│ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ │ ├── message_loc: (159...160) = "b"
│ │ │ │ │ │ ├── message_loc: (17,12)-(17,13) = "b"
│ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ ├── closing_loc: ∅
@ -324,14 +324,14 @@
│ │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ │ └── name: "b"
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (160...163) = "[1]"
│ │ │ │ │ ├── opening_loc: (160...161) = "["
│ │ │ │ │ ├── message_loc: (17,13)-(17,16) = "[1]"
│ │ │ │ │ ├── opening_loc: (17,13)-(17,14) = "["
│ │ │ │ │ ├── arguments:
│ │ │ │ │ │ @ ArgumentsNode (location: (161...162))
│ │ │ │ │ │ @ ArgumentsNode (location: (17,14)-(17,15))
│ │ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ │ └── @ IntegerNode (location: (161...162))
│ │ │ │ │ │ └── @ IntegerNode (location: (17,14)-(17,15))
│ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ ├── closing_loc: (162...163) = "]"
│ │ │ │ │ ├── closing_loc: (17,15)-(17,16) = "]"
│ │ │ │ │ ├── block: ∅
│ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "[]"
@ -341,31 +341,31 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (154...155) = "|"
│ │ │ └── closing_loc: (163...164) = "|"
│ │ │ ├── opening_loc: (17,7)-(17,8) = "|"
│ │ │ └── closing_loc: (17,16)-(17,17) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (151...153) = "do"
│ │ └── closing_loc: (165...168) = "end"
│ │ ├── opening_loc: (17,4)-(17,6) = "do"
│ │ └── closing_loc: (18,0)-(18,3) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (170...187))
├── @ CallNode (location: (20,0)-(22,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (170...173) = "foo"
│ ├── message_loc: (20,0)-(20,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (174...187))
│ │ @ BlockNode (location: (20,4)-(22,3))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ BeginNode (location: (177...187))
│ │ │ @ BeginNode (location: (21,0)-(22,3))
│ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause:
│ │ │ │ @ RescueNode (location: (177...183))
│ │ │ │ ├── keyword_loc: (177...183) = "rescue"
│ │ │ │ @ RescueNode (location: (21,0)-(21,6))
│ │ │ │ ├── keyword_loc: (21,0)-(21,6) = "rescue"
│ │ │ │ ├── exceptions: (length: 0)
│ │ │ │ ├── operator_loc: ∅
│ │ │ │ ├── reference: ∅
@ -373,69 +373,69 @@
│ │ │ │ └── consequent: ∅
│ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause: ∅
│ │ │ └── end_keyword_loc: (184...187) = "end"
│ │ ├── opening_loc: (174...176) = "do"
│ │ └── closing_loc: (184...187) = "end"
│ │ │ └── end_keyword_loc: (22,0)-(22,3) = "end"
│ │ ├── opening_loc: (20,4)-(20,6) = "do"
│ │ └── closing_loc: (22,0)-(22,3) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (189...233))
├── @ CallNode (location: (24,0)-(29,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (189...192) = "foo"
│ ├── message_loc: (24,0)-(24,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (193...233))
│ │ @ BlockNode (location: (24,4)-(29,3))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (198...229))
│ │ │ @ StatementsNode (location: (25,2)-(28,5))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (198...229))
│ │ │ └── @ CallNode (location: (25,2)-(28,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (198...201) = "bar"
│ │ │ ├── message_loc: (25,2)-(25,5) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (202...229))
│ │ │ │ @ BlockNode (location: (25,6)-(28,5))
│ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body:
│ │ │ │ │ @ StatementsNode (location: (209...223))
│ │ │ │ │ @ StatementsNode (location: (26,4)-(27,7))
│ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (209...223))
│ │ │ │ │ └── @ CallNode (location: (26,4)-(27,7))
│ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (209...212) = "baz"
│ │ │ │ │ ├── message_loc: (26,4)-(26,7) = "baz"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block:
│ │ │ │ │ │ @ BlockNode (location: (213...223))
│ │ │ │ │ │ @ BlockNode (location: (26,8)-(27,7))
│ │ │ │ │ │ ├── locals: []
│ │ │ │ │ │ ├── parameters: ∅
│ │ │ │ │ │ ├── body: ∅
│ │ │ │ │ │ ├── opening_loc: (213...215) = "do"
│ │ │ │ │ │ └── closing_loc: (220...223) = "end"
│ │ │ │ │ │ ├── opening_loc: (26,8)-(26,10) = "do"
│ │ │ │ │ │ └── closing_loc: (27,4)-(27,7) = "end"
│ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "baz"
│ │ │ │ ├── opening_loc: (202...204) = "do"
│ │ │ │ └── closing_loc: (226...229) = "end"
│ │ │ │ ├── opening_loc: (25,6)-(25,8) = "do"
│ │ │ │ └── closing_loc: (28,2)-(28,5) = "end"
│ │ │ ├── flags: ∅
│ │ │ └── name: "bar"
│ │ ├── opening_loc: (193...195) = "do"
│ │ └── closing_loc: (230...233) = "end"
│ │ ├── opening_loc: (24,4)-(24,6) = "do"
│ │ └── closing_loc: (29,0)-(29,3) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (235...251))
├── @ CallNode (location: (31,0)-(31,16))
│ ├── receiver:
│ │ @ CallNode (location: (235...238))
│ │ @ CallNode (location: (31,0)-(31,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (235...238) = "foo"
│ │ ├── message_loc: (31,0)-(31,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -443,106 +443,106 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (238...243) = "[bar]"
│ ├── opening_loc: (238...239) = "["
│ ├── message_loc: (31,3)-(31,8) = "[bar]"
│ ├── opening_loc: (31,3)-(31,4) = "["
│ ├── arguments:
│ │ @ ArgumentsNode (location: (239...242))
│ │ @ ArgumentsNode (location: (31,4)-(31,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (239...242))
│ │ └── @ CallNode (location: (31,4)-(31,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (239...242) = "bar"
│ │ ├── message_loc: (31,4)-(31,7) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "bar"
│ ├── closing_loc: (242...243) = "]"
│ ├── closing_loc: (31,7)-(31,8) = "]"
│ ├── block:
│ │ @ BlockNode (location: (244...251))
│ │ @ BlockNode (location: (31,9)-(31,16))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (246...249))
│ │ │ @ StatementsNode (location: (31,11)-(31,14))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (246...249))
│ │ │ └── @ CallNode (location: (31,11)-(31,14))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (246...249) = "baz"
│ │ │ ├── message_loc: (31,11)-(31,14) = "baz"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "baz"
│ │ ├── opening_loc: (244...245) = "{"
│ │ └── closing_loc: (250...251) = "}"
│ │ ├── opening_loc: (31,9)-(31,10) = "{"
│ │ └── closing_loc: (31,15)-(31,16) = "}"
│ ├── flags: ∅
│ └── name: "[]"
├── @ CallNode (location: (253...277))
├── @ CallNode (location: (33,0)-(33,24))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (253...256) = "foo"
│ ├── message_loc: (33,0)-(33,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (257...277))
│ │ @ BlockNode (location: (33,4)-(33,24))
│ │ ├── locals: [:x, :y, :z]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (259...273))
│ │ │ @ BlockParametersNode (location: (33,6)-(33,20))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (260...272))
│ │ │ │ @ ParametersNode (location: (33,7)-(33,19))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (260...261))
│ │ │ │ │ └── @ RequiredParameterNode (location: (33,7)-(33,8))
│ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 1)
│ │ │ │ │ └── @ OptionalParameterNode (location: (263...268))
│ │ │ │ │ └── @ OptionalParameterNode (location: (33,10)-(33,15))
│ │ │ │ │ ├── name: :y
│ │ │ │ │ ├── name_loc: (263...264) = "y"
│ │ │ │ │ ├── operator_loc: (265...266) = "="
│ │ │ │ │ ├── name_loc: (33,10)-(33,11) = "y"
│ │ │ │ │ ├── operator_loc: (33,12)-(33,13) = "="
│ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (267...268))
│ │ │ │ │ @ IntegerNode (location: (33,14)-(33,15))
│ │ │ │ │ └── flags: decimal
│ │ │ │ ├── rest: ∅
│ │ │ │ ├── posts: (length: 0)
│ │ │ │ ├── keywords: (length: 1)
│ │ │ │ │ └── @ KeywordParameterNode (location: (270...272))
│ │ │ │ │ └── @ KeywordParameterNode (location: (33,17)-(33,19))
│ │ │ │ │ ├── name: :z
│ │ │ │ │ ├── name_loc: (270...272) = "z:"
│ │ │ │ │ ├── name_loc: (33,17)-(33,19) = "z:"
│ │ │ │ │ └── value: ∅
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (259...260) = "|"
│ │ │ └── closing_loc: (272...273) = "|"
│ │ │ ├── opening_loc: (33,6)-(33,7) = "|"
│ │ │ └── closing_loc: (33,19)-(33,20) = "|"
│ │ ├── body:
│ │ │ @ StatementsNode (location: (274...275))
│ │ │ @ StatementsNode (location: (33,21)-(33,22))
│ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableReadNode (location: (274...275))
│ │ │ └── @ LocalVariableReadNode (location: (33,21)-(33,22))
│ │ │ ├── name: :x
│ │ │ └── depth: 0
│ │ ├── opening_loc: (257...258) = "{"
│ │ └── closing_loc: (276...277) = "}"
│ │ ├── opening_loc: (33,4)-(33,5) = "{"
│ │ └── closing_loc: (33,23)-(33,24) = "}"
│ ├── flags: ∅
│ └── name: "foo"
├── @ CallNode (location: (279...290))
├── @ CallNode (location: (35,0)-(35,11))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (279...282) = "foo"
│ ├── message_loc: (35,0)-(35,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (283...290))
│ │ @ BlockNode (location: (35,4)-(35,11))
│ │ ├── locals: [:x]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (285...288))
│ │ │ @ BlockParametersNode (location: (35,6)-(35,9))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (286...287))
│ │ │ │ @ ParametersNode (location: (35,7)-(35,8))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (286...287))
│ │ │ │ │ └── @ RequiredParameterNode (location: (35,7)-(35,8))
│ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -551,37 +551,37 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (285...286) = "|"
│ │ │ └── closing_loc: (287...288) = "|"
│ │ │ ├── opening_loc: (35,6)-(35,7) = "|"
│ │ │ └── closing_loc: (35,8)-(35,9) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (283...284) = "{"
│ │ └── closing_loc: (289...290) = "}"
│ │ ├── opening_loc: (35,4)-(35,5) = "{"
│ │ └── closing_loc: (35,10)-(35,11) = "}"
│ ├── flags: ∅
│ └── name: "foo"
├── @ LocalVariableWriteNode (location: (292...300))
├── @ LocalVariableWriteNode (location: (37,0)-(37,8))
│ ├── name: :fork
│ ├── depth: 0
│ ├── name_loc: (292...296) = "fork"
│ ├── name_loc: (37,0)-(37,4) = "fork"
│ ├── value:
│ │ @ IntegerNode (location: (299...300))
│ │ @ IntegerNode (location: (37,7)-(37,8))
│ │ └── flags: decimal
│ └── operator_loc: (297...298) = "="
├── @ CallNode (location: (301...316))
│ └── operator_loc: (37,5)-(37,6) = "="
├── @ CallNode (location: (38,0)-(39,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (301...305) = "fork"
│ ├── message_loc: (38,0)-(38,4) = "fork"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (306...316))
│ │ @ BlockNode (location: (38,5)-(39,3))
│ │ ├── locals: [:a]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (309...312))
│ │ │ @ BlockParametersNode (location: (38,8)-(38,11))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (310...311))
│ │ │ │ @ ParametersNode (location: (38,9)-(38,10))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (310...311))
│ │ │ │ │ └── @ RequiredParameterNode (location: (38,9)-(38,10))
│ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -590,29 +590,29 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (309...310) = "|"
│ │ │ └── closing_loc: (311...312) = "|"
│ │ │ ├── opening_loc: (38,8)-(38,9) = "|"
│ │ │ └── closing_loc: (38,10)-(38,11) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (306...308) = "do"
│ │ └── closing_loc: (313...316) = "end"
│ │ ├── opening_loc: (38,5)-(38,7) = "do"
│ │ └── closing_loc: (39,0)-(39,3) = "end"
│ ├── flags: ∅
│ └── name: "fork"
├── @ CallNode (location: (318...330))
├── @ CallNode (location: (41,0)-(41,12))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (318...322) = "fork"
│ ├── message_loc: (41,0)-(41,4) = "fork"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (323...330))
│ │ @ BlockNode (location: (41,5)-(41,12))
│ │ ├── locals: [:a]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (325...328))
│ │ │ @ BlockParametersNode (location: (41,7)-(41,10))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (326...327))
│ │ │ │ @ ParametersNode (location: (41,8)-(41,9))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (326...327))
│ │ │ │ │ └── @ RequiredParameterNode (location: (41,8)-(41,9))
│ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -621,130 +621,130 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (325...326) = "|"
│ │ │ └── closing_loc: (327...328) = "|"
│ │ │ ├── opening_loc: (41,7)-(41,8) = "|"
│ │ │ └── closing_loc: (41,9)-(41,10) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (323...324) = "{"
│ │ └── closing_loc: (329...330) = "}"
│ │ ├── opening_loc: (41,5)-(41,6) = "{"
│ │ └── closing_loc: (41,11)-(41,12) = "}"
│ ├── flags: ∅
│ └── name: "fork"
├── @ CallNode (location: (332...340))
├── @ CallNode (location: (43,0)-(44,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (332...333) = "C"
│ ├── message_loc: (43,0)-(43,1) = "C"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (334...340))
│ │ @ BlockNode (location: (43,2)-(44,3))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (334...336) = "do"
│ │ └── closing_loc: (337...340) = "end"
│ │ ├── opening_loc: (43,2)-(43,4) = "do"
│ │ └── closing_loc: (44,0)-(44,3) = "end"
│ ├── flags: ∅
│ └── name: "C"
├── @ CallNode (location: (342...346))
├── @ CallNode (location: (46,0)-(46,4))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (342...343) = "C"
│ ├── message_loc: (46,0)-(46,1) = "C"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (344...346))
│ │ @ BlockNode (location: (46,2)-(46,4))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (344...345) = "{"
│ │ └── closing_loc: (345...346) = "}"
│ │ ├── opening_loc: (46,2)-(46,3) = "{"
│ │ └── closing_loc: (46,3)-(46,4) = "}"
│ ├── flags: ∅
│ └── name: "C"
├── @ CallNode (location: (348...383))
├── @ CallNode (location: (48,0)-(52,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (348...351) = "foo"
│ ├── message_loc: (48,0)-(48,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (352...383))
│ │ @ ArgumentsNode (location: (48,4)-(52,1))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (352...383))
│ │ └── @ CallNode (location: (48,4)-(52,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (352...358) = "lambda"
│ │ ├── message_loc: (48,4)-(48,10) = "lambda"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block:
│ │ │ @ BlockNode (location: (359...383))
│ │ │ @ BlockNode (location: (48,11)-(52,1))
│ │ │ ├── locals: [:a, :b]
│ │ │ ├── parameters:
│ │ │ │ @ BlockParametersNode (location: (361...381))
│ │ │ │ @ BlockParametersNode (location: (48,13)-(51,3))
│ │ │ │ ├── parameters:
│ │ │ │ │ @ ParametersNode (location: (365...377))
│ │ │ │ │ @ ParametersNode (location: (49,2)-(50,6))
│ │ │ │ │ ├── requireds: (length: 0)
│ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ ├── rest: ∅
│ │ │ │ │ ├── posts: (length: 0)
│ │ │ │ │ ├── keywords: (length: 2)
│ │ │ │ │ │ ├── @ KeywordParameterNode (location: (365...369))
│ │ │ │ │ │ ├── @ KeywordParameterNode (location: (49,2)-(49,6))
│ │ │ │ │ │ │ ├── name: :a
│ │ │ │ │ │ │ ├── name_loc: (365...367) = "a:"
│ │ │ │ │ │ │ ├── name_loc: (49,2)-(49,4) = "a:"
│ │ │ │ │ │ │ └── value:
│ │ │ │ │ │ │ @ IntegerNode (location: (368...369))
│ │ │ │ │ │ │ @ IntegerNode (location: (49,5)-(49,6))
│ │ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ │ └── @ KeywordParameterNode (location: (373...377))
│ │ │ │ │ │ └── @ KeywordParameterNode (location: (50,2)-(50,6))
│ │ │ │ │ │ ├── name: :b
│ │ │ │ │ │ ├── name_loc: (373...375) = "b:"
│ │ │ │ │ │ ├── name_loc: (50,2)-(50,4) = "b:"
│ │ │ │ │ │ └── value:
│ │ │ │ │ │ @ IntegerNode (location: (376...377))
│ │ │ │ │ │ @ IntegerNode (location: (50,5)-(50,6))
│ │ │ │ │ │ └── flags: decimal
│ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ └── block: ∅
│ │ │ │ ├── locals: (length: 0)
│ │ │ │ ├── opening_loc: (361...362) = "|"
│ │ │ │ └── closing_loc: (380...381) = "|"
│ │ │ │ ├── opening_loc: (48,13)-(48,14) = "|"
│ │ │ │ └── closing_loc: (51,2)-(51,3) = "|"
│ │ │ ├── body: ∅
│ │ │ ├── opening_loc: (359...360) = "{"
│ │ │ └── closing_loc: (382...383) = "}"
│ │ │ ├── opening_loc: (48,11)-(48,12) = "{"
│ │ │ └── closing_loc: (52,0)-(52,1) = "}"
│ │ ├── flags: ∅
│ │ └── name: "lambda"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "foo"
└── @ CallNode (location: (385...402))
└── @ CallNode (location: (54,0)-(54,17))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (385...388) = "foo"
├── message_loc: (54,0)-(54,3) = "foo"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (389...402))
│ @ BlockNode (location: (54,4)-(54,17))
│ ├── locals: [:bar]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (392...398))
│ │ @ BlockParametersNode (location: (54,7)-(54,13))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (393...397))
│ │ │ @ ParametersNode (location: (54,8)-(54,12))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (393...396))
│ │ │ │ └── @ RequiredParameterNode (location: (54,8)-(54,11))
│ │ │ │ └── name: :bar
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (396...397))
│ │ │ │ @ RestParameterNode (location: (54,11)-(54,12))
│ │ │ │ ├── name: nil
│ │ │ │ ├── name_loc: ∅
│ │ │ │ └── operator_loc: (396...397) = ","
│ │ │ │ └── operator_loc: (54,11)-(54,12) = ","
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (392...393) = "|"
│ │ └── closing_loc: (397...398) = "|"
│ │ ├── opening_loc: (54,7)-(54,8) = "|"
│ │ └── closing_loc: (54,12)-(54,13) = "|"
│ ├── body: ∅
│ ├── opening_loc: (389...391) = "do"
│ └── closing_loc: (399...402) = "end"
│ ├── opening_loc: (54,4)-(54,6) = "do"
│ └── closing_loc: (54,14)-(54,17) = "end"
├── flags: ∅
└── 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]
└── statements:
@ StatementsNode (location: (0...24))
@ StatementsNode (location: (1,0)-(5,7))
└── body: (length: 3)
├── @ LocalVariableAndWriteNode (location: (0...7))
│ ├── name_loc: (0...1) = "a"
│ ├── operator_loc: (2...5) = "&&="
├── @ LocalVariableAndWriteNode (location: (1,0)-(1,7))
│ ├── name_loc: (1,0)-(1,1) = "a"
│ ├── operator_loc: (1,2)-(1,5) = "&&="
│ ├── value:
│ │ @ CallNode (location: (6...7))
│ │ @ CallNode (location: (1,6)-(1,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (6...7) = "b"
│ │ ├── message_loc: (1,6)-(1,7) = "b"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -19,14 +19,14 @@
│ │ └── name: "b"
│ ├── name: :a
│ └── depth: 0
├── @ LocalVariableOperatorWriteNode (location: (9...15))
│ ├── name_loc: (9...10) = "a"
│ ├── operator_loc: (11...13) = "+="
├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,6))
│ ├── name_loc: (3,0)-(3,1) = "a"
│ ├── operator_loc: (3,2)-(3,4) = "+="
│ ├── value:
│ │ @ CallNode (location: (14...15))
│ │ @ CallNode (location: (3,5)-(3,6))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (14...15) = "b"
│ │ ├── message_loc: (3,5)-(3,6) = "b"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -36,14 +36,14 @@
│ ├── name: :a
│ ├── operator: :+
│ └── depth: 0
└── @ LocalVariableOrWriteNode (location: (17...24))
├── name_loc: (17...18) = "a"
├── operator_loc: (19...22) = "||="
└── @ LocalVariableOrWriteNode (location: (5,0)-(5,7))
├── name_loc: (5,0)-(5,1) = "a"
├── operator_loc: (5,2)-(5,5) = "||="
├── value:
│ @ CallNode (location: (23...24))
│ @ CallNode (location: (5,6)-(5,7))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (23...24) = "b"
│ ├── message_loc: (5,6)-(5,7) = "b"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── 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: []
└── statements:
@ StatementsNode (location: (0...11))
@ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 2)
├── @ FalseNode (location: (0...5))
└── @ TrueNode (location: (7...11))
├── @ FalseNode (location: (1,0)-(1,5))
└── @ 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: []
└── statements:
@ StatementsNode (location: (0...168))
@ StatementsNode (location: (1,0)-(25,23))
└── body: (length: 11)
├── @ BreakNode (location: (0...5))
├── @ BreakNode (location: (1,0)-(1,5))
│ ├── arguments: ∅
│ └── keyword_loc: (0...5) = "break"
├── @ BreakNode (location: (7...26))
│ └── keyword_loc: (1,0)-(1,5) = "break"
├── @ BreakNode (location: (3,0)-(3,19))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (13...26))
│ │ @ ArgumentsNode (location: (3,6)-(3,19))
│ │ └── arguments: (length: 3)
│ │ ├── @ ParenthesesNode (location: (13...16))
│ │ ├── @ ParenthesesNode (location: (3,6)-(3,9))
│ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (14...15))
│ │ │ │ @ StatementsNode (location: (3,7)-(3,8))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (14...15))
│ │ │ │ └── @ IntegerNode (location: (3,7)-(3,8))
│ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (13...14) = "("
│ │ │ └── closing_loc: (15...16) = ")"
│ │ ├── @ ParenthesesNode (location: (18...21))
│ │ │ ├── opening_loc: (3,6)-(3,7) = "("
│ │ │ └── closing_loc: (3,8)-(3,9) = ")"
│ │ ├── @ ParenthesesNode (location: (3,11)-(3,14))
│ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (19...20))
│ │ │ │ @ StatementsNode (location: (3,12)-(3,13))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (19...20))
│ │ │ │ └── @ IntegerNode (location: (3,12)-(3,13))
│ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (18...19) = "("
│ │ │ └── closing_loc: (20...21) = ")"
│ │ └── @ ParenthesesNode (location: (23...26))
│ │ │ ├── opening_loc: (3,11)-(3,12) = "("
│ │ │ └── closing_loc: (3,13)-(3,14) = ")"
│ │ └── @ ParenthesesNode (location: (3,16)-(3,19))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (24...25))
│ │ │ @ StatementsNode (location: (3,17)-(3,18))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (24...25))
│ │ │ └── @ IntegerNode (location: (3,17)-(3,18))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (23...24) = "("
│ │ └── closing_loc: (25...26) = ")"
│ └── keyword_loc: (7...12) = "break"
├── @ BreakNode (location: (28...35))
│ │ ├── opening_loc: (3,16)-(3,17) = "("
│ │ └── closing_loc: (3,18)-(3,19) = ")"
│ └── keyword_loc: (3,0)-(3,5) = "break"
├── @ BreakNode (location: (5,0)-(5,7))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (34...35))
│ │ @ ArgumentsNode (location: (5,6)-(5,7))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (34...35))
│ │ └── @ IntegerNode (location: (5,6)-(5,7))
│ │ └── flags: decimal
│ └── keyword_loc: (28...33) = "break"
├── @ BreakNode (location: (37...50))
│ └── keyword_loc: (5,0)-(5,5) = "break"
├── @ BreakNode (location: (7,0)-(8,1))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (43...50))
│ │ @ ArgumentsNode (location: (7,6)-(8,1))
│ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (43...44))
│ │ ├── @ IntegerNode (location: (7,6)-(7,7))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (46...47))
│ │ ├── @ IntegerNode (location: (7,9)-(7,10))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (49...50))
│ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal
│ └── keyword_loc: (37...42) = "break"
├── @ BreakNode (location: (52...65))
│ └── keyword_loc: (7,0)-(7,5) = "break"
├── @ BreakNode (location: (10,0)-(10,13))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (58...65))
│ │ @ ArgumentsNode (location: (10,6)-(10,13))
│ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (58...59))
│ │ ├── @ IntegerNode (location: (10,6)-(10,7))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (61...62))
│ │ ├── @ IntegerNode (location: (10,9)-(10,10))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (64...65))
│ │ └── @ IntegerNode (location: (10,12)-(10,13))
│ │ └── flags: decimal
│ └── keyword_loc: (52...57) = "break"
├── @ BreakNode (location: (67...82))
│ └── keyword_loc: (10,0)-(10,5) = "break"
├── @ BreakNode (location: (12,0)-(12,15))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (73...82))
│ │ @ ArgumentsNode (location: (12,6)-(12,15))
│ │ └── arguments: (length: 1)
│ │ └── @ ArrayNode (location: (73...82))
│ │ └── @ ArrayNode (location: (12,6)-(12,15))
│ │ ├── elements: (length: 3)
│ │ │ ├── @ IntegerNode (location: (74...75))
│ │ │ ├── @ IntegerNode (location: (12,7)-(12,8))
│ │ │ │ └── flags: decimal
│ │ │ ├── @ IntegerNode (location: (77...78))
│ │ │ ├── @ IntegerNode (location: (12,10)-(12,11))
│ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (80...81))
│ │ │ └── @ IntegerNode (location: (12,13)-(12,14))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (73...74) = "["
│ │ └── closing_loc: (81...82) = "]"
│ └── keyword_loc: (67...72) = "break"
├── @ BreakNode (location: (84...100))
│ │ ├── opening_loc: (12,6)-(12,7) = "["
│ │ └── closing_loc: (12,14)-(12,15) = "]"
│ └── keyword_loc: (12,0)-(12,5) = "break"
├── @ BreakNode (location: (14,0)-(17,1))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (89...100))
│ │ @ ArgumentsNode (location: (14,5)-(17,1))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (89...100))
│ │ └── @ ParenthesesNode (location: (14,5)-(17,1))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (93...98))
│ │ │ @ StatementsNode (location: (15,2)-(16,3))
│ │ │ └── body: (length: 2)
│ │ │ ├── @ IntegerNode (location: (93...94))
│ │ │ ├── @ IntegerNode (location: (15,2)-(15,3))
│ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (97...98))
│ │ │ └── @ IntegerNode (location: (16,2)-(16,3))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (89...90) = "("
│ │ └── closing_loc: (99...100) = ")"
│ └── keyword_loc: (84...89) = "break"
├── @ BreakNode (location: (102...109))
│ │ ├── opening_loc: (14,5)-(14,6) = "("
│ │ └── closing_loc: (17,0)-(17,1) = ")"
│ └── keyword_loc: (14,0)-(14,5) = "break"
├── @ BreakNode (location: (19,0)-(19,7))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (107...109))
│ │ @ ArgumentsNode (location: (19,5)-(19,7))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (107...109))
│ │ └── @ ParenthesesNode (location: (19,5)-(19,7))
│ │ ├── body: ∅
│ │ ├── opening_loc: (107...108) = "("
│ │ └── closing_loc: (108...109) = ")"
│ └── keyword_loc: (102...107) = "break"
├── @ BreakNode (location: (111...119))
│ │ ├── opening_loc: (19,5)-(19,6) = "("
│ │ └── closing_loc: (19,6)-(19,7) = ")"
│ └── keyword_loc: (19,0)-(19,5) = "break"
├── @ BreakNode (location: (21,0)-(21,8))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (116...119))
│ │ @ ArgumentsNode (location: (21,5)-(21,8))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (116...119))
│ │ └── @ ParenthesesNode (location: (21,5)-(21,8))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (117...118))
│ │ │ @ StatementsNode (location: (21,6)-(21,7))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (117...118))
│ │ │ └── @ IntegerNode (location: (21,6)-(21,7))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (116...117) = "("
│ │ └── closing_loc: (118...119) = ")"
│ └── keyword_loc: (111...116) = "break"
├── @ CallNode (location: (121...143))
│ │ ├── opening_loc: (21,5)-(21,6) = "("
│ │ └── closing_loc: (21,7)-(21,8) = ")"
│ └── keyword_loc: (21,0)-(21,5) = "break"
├── @ CallNode (location: (23,0)-(23,22))
│ ├── receiver:
│ │ @ CallNode (location: (121...137))
│ │ @ CallNode (location: (23,0)-(23,16))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (121...124) = "foo"
│ │ ├── message_loc: (23,0)-(23,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block:
│ │ │ @ BlockNode (location: (125...137))
│ │ │ @ BlockNode (location: (23,4)-(23,16))
│ │ │ ├── locals: []
│ │ │ ├── parameters: ∅
│ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (127...135))
│ │ │ │ @ StatementsNode (location: (23,6)-(23,14))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ BreakNode (location: (127...135))
│ │ │ │ └── @ BreakNode (location: (23,6)-(23,14))
│ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (133...135))
│ │ │ │ │ @ ArgumentsNode (location: (23,12)-(23,14))
│ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (133...135))
│ │ │ │ │ └── @ IntegerNode (location: (23,12)-(23,14))
│ │ │ │ │ └── flags: decimal
│ │ │ │ └── keyword_loc: (127...132) = "break"
│ │ │ ├── opening_loc: (125...126) = "{"
│ │ │ └── closing_loc: (136...137) = "}"
│ │ │ │ └── keyword_loc: (23,6)-(23,11) = "break"
│ │ │ ├── opening_loc: (23,4)-(23,5) = "{"
│ │ │ └── closing_loc: (23,15)-(23,16) = "}"
│ │ ├── flags: ∅
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (138...140) = "=="
│ ├── message_loc: (23,17)-(23,19) = "=="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (141...143))
│ │ @ ArgumentsNode (location: (23,20)-(23,22))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (141...143))
│ │ └── @ IntegerNode (location: (23,20)-(23,22))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "=="
└── @ CallNode (location: (145...168))
└── @ CallNode (location: (25,0)-(25,23))
├── receiver:
│ @ CallNode (location: (145...162))
│ @ CallNode (location: (25,0)-(25,17))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (145...148) = "foo"
│ ├── message_loc: (25,0)-(25,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (149...162))
│ │ @ BlockNode (location: (25,4)-(25,17))
│ │ ├── locals: [:a]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (151...154))
│ │ │ @ BlockParametersNode (location: (25,6)-(25,9))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (152...153))
│ │ │ │ @ ParametersNode (location: (25,7)-(25,8))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (152...153))
│ │ │ │ │ └── @ RequiredParameterNode (location: (25,7)-(25,8))
│ │ │ │ │ └── name: :a
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -181,25 +181,25 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (151...152) = "|"
│ │ │ └── closing_loc: (153...154) = "|"
│ │ │ ├── opening_loc: (25,6)-(25,7) = "|"
│ │ │ └── closing_loc: (25,8)-(25,9) = "|"
│ │ ├── body:
│ │ │ @ StatementsNode (location: (155...160))
│ │ │ @ StatementsNode (location: (25,10)-(25,15))
│ │ │ └── body: (length: 1)
│ │ │ └── @ BreakNode (location: (155...160))
│ │ │ └── @ BreakNode (location: (25,10)-(25,15))
│ │ │ ├── arguments: ∅
│ │ │ └── keyword_loc: (155...160) = "break"
│ │ ├── opening_loc: (149...150) = "{"
│ │ └── closing_loc: (161...162) = "}"
│ │ │ └── keyword_loc: (25,10)-(25,15) = "break"
│ │ ├── opening_loc: (25,4)-(25,5) = "{"
│ │ └── closing_loc: (25,16)-(25,17) = "}"
│ ├── flags: ∅
│ └── name: "foo"
├── call_operator_loc: ∅
├── message_loc: (163...165) = "=="
├── message_loc: (25,18)-(25,20) = "=="
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (166...168))
│ @ ArgumentsNode (location: (25,21)-(25,23))
│ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (166...168))
│ └── @ IntegerNode (location: (25,21)-(25,23))
│ └── flags: decimal
├── closing_loc: ∅
├── block: ∅

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

@ -1,74 +1,74 @@
@ ProgramNode (location: (0...299))
@ ProgramNode (location: (1,0)-(32,25))
├── locals: []
└── statements:
@ StatementsNode (location: (0...299))
@ StatementsNode (location: (1,0)-(32,25))
└── body: (length: 9)
├── @ CaseNode (location: (0...21))
├── @ CaseNode (location: (1,0)-(3,3))
│ ├── predicate:
│ │ @ SymbolNode (location: (5...8))
│ │ ├── opening_loc: (5...6) = ":"
│ │ ├── value_loc: (6...8) = "hi"
│ │ @ SymbolNode (location: (1,5)-(1,8))
│ │ ├── opening_loc: (1,5)-(1,6) = ":"
│ │ ├── value_loc: (1,6)-(1,8) = "hi"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "hi"
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (9...17))
│ │ ├── keyword_loc: (9...13) = "when"
│ │ └── @ WhenNode (location: (2,0)-(2,8))
│ │ ├── keyword_loc: (2,0)-(2,4) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (14...17))
│ │ │ ├── opening_loc: (14...15) = ":"
│ │ │ ├── value_loc: (15...17) = "hi"
│ │ │ └── @ SymbolNode (location: (2,5)-(2,8))
│ │ │ ├── opening_loc: (2,5)-(2,6) = ":"
│ │ │ ├── value_loc: (2,6)-(2,8) = "hi"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "hi"
│ │ └── statements: ∅
│ ├── consequent: ∅
│ ├── case_keyword_loc: (0...4) = "case"
│ └── end_keyword_loc: (18...21) = "end"
├── @ CaseNode (location: (23...81))
│ ├── case_keyword_loc: (1,0)-(1,4) = "case"
│ └── end_keyword_loc: (3,0)-(3,3) = "end"
├── @ CaseNode (location: (5,0)-(5,58))
│ ├── predicate:
│ │ @ TrueNode (location: (28...32))
│ │ @ TrueNode (location: (5,5)-(5,9))
│ ├── conditions: (length: 2)
│ │ ├── @ WhenNode (location: (34...53))
│ │ │ ├── keyword_loc: (34...38) = "when"
│ │ ├── @ WhenNode (location: (5,11)-(5,30))
│ │ │ ├── keyword_loc: (5,11)-(5,15) = "when"
│ │ │ ├── conditions: (length: 1)
│ │ │ │ └── @ TrueNode (location: (39...43))
│ │ │ │ └── @ TrueNode (location: (5,16)-(5,20))
│ │ │ └── statements:
│ │ │ @ StatementsNode (location: (45...53))
│ │ │ @ StatementsNode (location: (5,22)-(5,30))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (45...53))
│ │ │ └── @ CallNode (location: (5,22)-(5,30))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (45...49) = "puts"
│ │ │ ├── message_loc: (5,22)-(5,26) = "puts"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (50...53))
│ │ │ │ @ ArgumentsNode (location: (5,27)-(5,30))
│ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ SymbolNode (location: (50...53))
│ │ │ │ ├── opening_loc: (50...51) = ":"
│ │ │ │ ├── value_loc: (51...53) = "hi"
│ │ │ │ └── @ SymbolNode (location: (5,27)-(5,30))
│ │ │ │ ├── opening_loc: (5,27)-(5,28) = ":"
│ │ │ │ ├── value_loc: (5,28)-(5,30) = "hi"
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "hi"
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: ∅
│ │ │ └── name: "puts"
│ │ └── @ WhenNode (location: (55...76))
│ │ ├── keyword_loc: (55...59) = "when"
│ │ └── @ WhenNode (location: (5,32)-(5,53))
│ │ ├── keyword_loc: (5,32)-(5,36) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ FalseNode (location: (60...65))
│ │ │ └── @ FalseNode (location: (5,37)-(5,42))
│ │ └── statements:
│ │ @ StatementsNode (location: (67...76))
│ │ @ StatementsNode (location: (5,44)-(5,53))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (67...76))
│ │ └── @ CallNode (location: (5,44)-(5,53))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (67...71) = "puts"
│ │ ├── message_loc: (5,44)-(5,48) = "puts"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (72...76))
│ │ │ @ ArgumentsNode (location: (5,49)-(5,53))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ SymbolNode (location: (72...76))
│ │ │ ├── opening_loc: (72...73) = ":"
│ │ │ ├── value_loc: (73...76) = "bye"
│ │ │ └── @ SymbolNode (location: (5,49)-(5,53))
│ │ │ ├── opening_loc: (5,49)-(5,50) = ":"
│ │ │ ├── value_loc: (5,50)-(5,53) = "bye"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "bye"
│ │ ├── closing_loc: ∅
@ -76,21 +76,21 @@
│ │ ├── flags: ∅
│ │ └── name: "puts"
│ ├── consequent: ∅
│ ├── case_keyword_loc: (23...27) = "case"
│ └── end_keyword_loc: (78...81) = "end"
├── @ CaseNode (location: (83...103))
│ ├── case_keyword_loc: (5,0)-(5,4) = "case"
│ └── end_keyword_loc: (5,55)-(5,58) = "end"
├── @ CaseNode (location: (7,0)-(7,20))
│ ├── predicate: ∅
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (89...98))
│ │ ├── keyword_loc: (89...93) = "when"
│ │ └── @ WhenNode (location: (7,6)-(7,15))
│ │ ├── keyword_loc: (7,6)-(7,10) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ SplatNode (location: (94...98))
│ │ │ ├── operator_loc: (94...95) = "*"
│ │ │ └── @ SplatNode (location: (7,11)-(7,15))
│ │ │ ├── operator_loc: (7,11)-(7,12) = "*"
│ │ │ └── expression:
│ │ │ @ CallNode (location: (95...98))
│ │ │ @ CallNode (location: (7,12)-(7,15))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (95...98) = "foo"
│ │ │ ├── message_loc: (7,12)-(7,15) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -99,45 +99,45 @@
│ │ │ └── name: "foo"
│ │ └── statements: ∅
│ ├── consequent: ∅
│ ├── case_keyword_loc: (83...87) = "case"
│ └── end_keyword_loc: (100...103) = "end"
├── @ CaseNode (location: (105...134))
│ ├── case_keyword_loc: (7,0)-(7,4) = "case"
│ └── end_keyword_loc: (7,17)-(7,20) = "end"
├── @ CaseNode (location: (9,0)-(13,3))
│ ├── predicate:
│ │ @ SymbolNode (location: (110...113))
│ │ ├── opening_loc: (110...111) = ":"
│ │ ├── value_loc: (111...113) = "hi"
│ │ @ SymbolNode (location: (9,5)-(9,8))
│ │ ├── opening_loc: (9,5)-(9,6) = ":"
│ │ ├── value_loc: (9,6)-(9,8) = "hi"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "hi"
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (114...122))
│ │ ├── keyword_loc: (114...118) = "when"
│ │ └── @ WhenNode (location: (10,0)-(10,8))
│ │ ├── keyword_loc: (10,0)-(10,4) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (119...122))
│ │ │ ├── opening_loc: (119...120) = ":"
│ │ │ ├── value_loc: (120...122) = "hi"
│ │ │ └── @ SymbolNode (location: (10,5)-(10,8))
│ │ │ ├── opening_loc: (10,5)-(10,6) = ":"
│ │ │ ├── value_loc: (10,6)-(10,8) = "hi"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "hi"
│ │ └── statements: ∅
│ ├── consequent:
│ │ @ ElseNode (location: (123...134))
│ │ ├── else_keyword_loc: (123...127) = "else"
│ │ @ ElseNode (location: (11,0)-(13,3))
│ │ ├── else_keyword_loc: (11,0)-(11,4) = "else"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (128...130))
│ │ │ @ StatementsNode (location: (12,0)-(12,2))
│ │ │ └── body: (length: 1)
│ │ │ └── @ SymbolNode (location: (128...130))
│ │ │ ├── opening_loc: (128...129) = ":"
│ │ │ ├── value_loc: (129...130) = "b"
│ │ │ └── @ SymbolNode (location: (12,0)-(12,2))
│ │ │ ├── opening_loc: (12,0)-(12,1) = ":"
│ │ │ ├── value_loc: (12,1)-(12,2) = "b"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "b"
│ │ └── end_keyword_loc: (131...134) = "end"
│ ├── case_keyword_loc: (105...109) = "case"
│ └── end_keyword_loc: (131...134) = "end"
├── @ CaseNode (location: (136...172))
│ │ └── end_keyword_loc: (13,0)-(13,3) = "end"
│ ├── case_keyword_loc: (9,0)-(9,4) = "case"
│ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ CaseNode (location: (15,0)-(15,36))
│ ├── predicate:
│ │ @ CallNode (location: (141...145))
│ │ @ CallNode (location: (15,5)-(15,9))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (141...145) = "this"
│ │ ├── message_loc: (15,5)-(15,9) = "this"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -145,29 +145,29 @@
│ │ ├── flags: variable_call
│ │ └── name: "this"
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (147...167))
│ │ ├── keyword_loc: (147...151) = "when"
│ │ └── @ WhenNode (location: (15,11)-(15,31))
│ │ ├── keyword_loc: (15,11)-(15,15) = "when"
│ │ ├── conditions: (length: 2)
│ │ │ ├── @ ConstantReadNode (location: (152...158))
│ │ │ ├── @ ConstantReadNode (location: (15,16)-(15,22))
│ │ │ │ └── name: :FooBar
│ │ │ └── @ ConstantReadNode (location: (160...167))
│ │ │ └── @ ConstantReadNode (location: (15,24)-(15,31))
│ │ │ └── name: :BazBonk
│ │ └── statements: ∅
│ ├── consequent: ∅
│ ├── case_keyword_loc: (136...140) = "case"
│ └── end_keyword_loc: (169...172) = "end"
├── @ CaseNode (location: (174...198))
│ ├── case_keyword_loc: (15,0)-(15,4) = "case"
│ └── end_keyword_loc: (15,33)-(15,36) = "end"
├── @ CaseNode (location: (17,0)-(19,3))
│ ├── predicate: ∅
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (179...194))
│ │ ├── keyword_loc: (179...183) = "when"
│ │ └── @ WhenNode (location: (18,0)-(18,15))
│ │ ├── keyword_loc: (18,0)-(18,4) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ CallNode (location: (184...194))
│ │ │ └── @ CallNode (location: (18,5)-(18,15))
│ │ │ ├── receiver:
│ │ │ │ @ CallNode (location: (184...187))
│ │ │ │ @ CallNode (location: (18,5)-(18,8))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (184...187) = "foo"
│ │ │ │ ├── message_loc: (18,5)-(18,8) = "foo"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -175,15 +175,15 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "foo"
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (188...190) = "=="
│ │ │ ├── message_loc: (18,9)-(18,11) = "=="
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (191...194))
│ │ │ │ @ ArgumentsNode (location: (18,12)-(18,15))
│ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ CallNode (location: (191...194))
│ │ │ │ └── @ CallNode (location: (18,12)-(18,15))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (191...194) = "bar"
│ │ │ │ ├── message_loc: (18,12)-(18,15) = "bar"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -196,18 +196,18 @@
│ │ │ └── name: "=="
│ │ └── statements: ∅
│ ├── consequent: ∅
│ ├── case_keyword_loc: (174...178) = "case"
│ └── end_keyword_loc: (195...198) = "end"
├── @ CaseNode (location: (200...230))
│ ├── case_keyword_loc: (17,0)-(17,4) = "case"
│ └── end_keyword_loc: (19,0)-(19,3) = "end"
├── @ CaseNode (location: (21,0)-(25,3))
│ ├── predicate: ∅
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (205...211))
│ │ ├── keyword_loc: (205...209) = "when"
│ │ └── @ WhenNode (location: (22,0)-(22,6))
│ │ ├── keyword_loc: (22,0)-(22,4) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ CallNode (location: (210...211))
│ │ │ └── @ CallNode (location: (22,5)-(22,6))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (210...211) = "a"
│ │ │ ├── message_loc: (22,5)-(22,6) = "a"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -216,18 +216,18 @@
│ │ │ └── name: "a"
│ │ └── statements: ∅
│ ├── consequent:
│ │ @ ElseNode (location: (212...230))
│ │ ├── else_keyword_loc: (212...216) = "else"
│ │ @ ElseNode (location: (23,0)-(25,3))
│ │ ├── else_keyword_loc: (23,0)-(23,4) = "else"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (227...230) = "end"
│ ├── case_keyword_loc: (200...204) = "case"
│ └── end_keyword_loc: (227...230) = "end"
├── @ CaseNode (location: (232...272))
│ │ └── end_keyword_loc: (25,0)-(25,3) = "end"
│ ├── case_keyword_loc: (21,0)-(21,4) = "case"
│ └── end_keyword_loc: (25,0)-(25,3) = "end"
├── @ CaseNode (location: (27,0)-(30,6))
│ ├── predicate:
│ │ @ CallNode (location: (237...241))
│ │ @ CallNode (location: (27,5)-(27,9))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (237...241) = "type"
│ │ ├── message_loc: (27,5)-(27,9) = "type"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -235,31 +235,31 @@
│ │ ├── flags: variable_call
│ │ └── name: "type"
│ ├── conditions: (length: 1)
│ │ └── @ WhenNode (location: (246...253))
│ │ ├── keyword_loc: (246...250) = "when"
│ │ └── @ WhenNode (location: (28,3)-(28,10))
│ │ ├── keyword_loc: (28,3)-(28,7) = "when"
│ │ ├── conditions: (length: 1)
│ │ │ └── @ SymbolNode (location: (251...253))
│ │ │ ├── opening_loc: (251...252) = ":"
│ │ │ ├── value_loc: (252...253) = "b"
│ │ │ └── @ SymbolNode (location: (28,8)-(28,10))
│ │ │ ├── opening_loc: (28,8)-(28,9) = ":"
│ │ │ ├── value_loc: (28,9)-(28,10) = "b"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "b"
│ │ └── statements: ∅
│ ├── consequent:
│ │ @ ElseNode (location: (260...272))
│ │ ├── else_keyword_loc: (260...264) = "else"
│ │ @ ElseNode (location: (29,5)-(30,6))
│ │ ├── else_keyword_loc: (29,5)-(29,9) = "else"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (269...272) = "end"
│ ├── case_keyword_loc: (232...236) = "case"
│ └── end_keyword_loc: (269...272) = "end"
└── @ CaseNode (location: (274...299))
│ │ └── end_keyword_loc: (30,3)-(30,6) = "end"
│ ├── case_keyword_loc: (27,0)-(27,4) = "case"
│ └── end_keyword_loc: (30,3)-(30,6) = "end"
└── @ CaseNode (location: (32,0)-(32,25))
├── predicate: ∅
├── conditions: (length: 1)
│ └── @ WhenNode (location: (288...294))
│ ├── keyword_loc: (288...292) = "when"
│ └── @ WhenNode (location: (32,14)-(32,20))
│ ├── keyword_loc: (32,14)-(32,18) = "when"
│ ├── conditions: (length: 1)
│ │ └── @ IntegerNode (location: (293...294))
│ │ └── @ IntegerNode (location: (32,19)-(32,20))
│ │ └── flags: decimal
│ └── statements: ∅
├── consequent: ∅
├── case_keyword_loc: (274...278) = "case"
└── end_keyword_loc: (296...299) = "end"
├── case_keyword_loc: (32,0)-(32,4) = "case"
└── 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: []
└── statements:
@ StatementsNode (location: (0...370))
@ StatementsNode (location: (1,0)-(35,3))
└── body: (length: 14)
├── @ ClassNode (location: (0...17))
├── @ ClassNode (location: (1,0)-(1,17))
│ ├── locals: [:a]
│ ├── class_keyword_loc: (0...5) = "class"
│ ├── class_keyword_loc: (1,0)-(1,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (6...7))
│ │ @ ConstantReadNode (location: (1,6)-(1,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (8...13))
│ │ @ StatementsNode (location: (1,8)-(1,13))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (8...13))
│ │ └── @ LocalVariableWriteNode (location: (1,8)-(1,13))
│ │ ├── name: :a
│ │ ├── depth: 0
│ │ ├── name_loc: (8...9) = "a"
│ │ ├── name_loc: (1,8)-(1,9) = "a"
│ │ ├── value:
│ │ │ @ IntegerNode (location: (12...13))
│ │ │ @ IntegerNode (location: (1,12)-(1,13))
│ │ │ └── flags: decimal
│ │ └── operator_loc: (10...11) = "="
│ ├── end_keyword_loc: (14...17) = "end"
│ │ └── operator_loc: (1,10)-(1,11) = "="
│ ├── end_keyword_loc: (1,14)-(1,17) = "end"
│ └── name: :A
├── @ ClassNode (location: (19...39))
├── @ ClassNode (location: (3,0)-(3,20))
│ ├── locals: []
│ ├── class_keyword_loc: (19...24) = "class"
│ ├── class_keyword_loc: (3,0)-(3,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (25...26))
│ │ @ ConstantReadNode (location: (3,6)-(3,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ BeginNode (location: (28...39))
│ │ @ BeginNode (location: (3,9)-(3,20))
│ │ ├── begin_keyword_loc: ∅
│ │ ├── statements: ∅
│ │ ├── rescue_clause: ∅
│ │ ├── else_clause: ∅
│ │ ├── ensure_clause:
│ │ │ @ EnsureNode (location: (28...39))
│ │ │ ├── ensure_keyword_loc: (28...34) = "ensure"
│ │ │ @ EnsureNode (location: (3,9)-(3,20))
│ │ │ ├── ensure_keyword_loc: (3,9)-(3,15) = "ensure"
│ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (36...39) = "end"
│ │ └── end_keyword_loc: (36...39) = "end"
│ ├── end_keyword_loc: (36...39) = "end"
│ │ │ └── end_keyword_loc: (3,17)-(3,20) = "end"
│ │ └── end_keyword_loc: (3,17)-(3,20) = "end"
│ ├── end_keyword_loc: (3,17)-(3,20) = "end"
│ └── name: :A
├── @ ClassNode (location: (41...75))
├── @ ClassNode (location: (5,0)-(5,34))
│ ├── locals: []
│ ├── class_keyword_loc: (41...46) = "class"
│ ├── class_keyword_loc: (5,0)-(5,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (47...48))
│ │ @ ConstantReadNode (location: (5,6)-(5,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ BeginNode (location: (50...75))
│ │ @ BeginNode (location: (5,9)-(5,34))
│ │ ├── begin_keyword_loc: ∅
│ │ ├── statements: ∅
│ │ ├── rescue_clause:
│ │ │ @ RescueNode (location: (50...56))
│ │ │ ├── keyword_loc: (50...56) = "rescue"
│ │ │ @ RescueNode (location: (5,9)-(5,15))
│ │ │ ├── keyword_loc: (5,9)-(5,15) = "rescue"
│ │ │ ├── exceptions: (length: 0)
│ │ │ ├── operator_loc: ∅
│ │ │ ├── reference: ∅
│ │ │ ├── statements: ∅
│ │ │ └── consequent: ∅
│ │ ├── else_clause:
│ │ │ @ ElseNode (location: (58...70))
│ │ │ ├── else_keyword_loc: (58...62) = "else"
│ │ │ @ ElseNode (location: (5,17)-(5,29))
│ │ │ ├── else_keyword_loc: (5,17)-(5,21) = "else"
│ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (64...70) = "ensure"
│ │ │ └── end_keyword_loc: (5,23)-(5,29) = "ensure"
│ │ ├── ensure_clause:
│ │ │ @ EnsureNode (location: (64...75))
│ │ │ ├── ensure_keyword_loc: (64...70) = "ensure"
│ │ │ @ EnsureNode (location: (5,23)-(5,34))
│ │ │ ├── ensure_keyword_loc: (5,23)-(5,29) = "ensure"
│ │ │ ├── statements: ∅
│ │ │ └── end_keyword_loc: (72...75) = "end"
│ │ └── end_keyword_loc: (72...75) = "end"
│ ├── end_keyword_loc: (72...75) = "end"
│ │ │ └── end_keyword_loc: (5,31)-(5,34) = "end"
│ │ └── end_keyword_loc: (5,31)-(5,34) = "end"
│ ├── end_keyword_loc: (5,31)-(5,34) = "end"
│ └── name: :A
├── @ ClassNode (location: (77...98))
├── @ ClassNode (location: (7,0)-(9,3))
│ ├── locals: [:a]
│ ├── class_keyword_loc: (77...82) = "class"
│ ├── class_keyword_loc: (7,0)-(7,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (83...84))
│ │ @ ConstantReadNode (location: (7,6)-(7,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: (85...86) = "<"
│ ├── inheritance_operator_loc: (7,8)-(7,9) = "<"
│ ├── superclass:
│ │ @ ConstantReadNode (location: (87...88))
│ │ @ ConstantReadNode (location: (7,10)-(7,11))
│ │ └── name: :B
│ ├── body:
│ │ @ StatementsNode (location: (89...94))
│ │ @ StatementsNode (location: (8,0)-(8,5))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (89...94))
│ │ └── @ LocalVariableWriteNode (location: (8,0)-(8,5))
│ │ ├── name: :a
│ │ ├── depth: 0
│ │ ├── name_loc: (89...90) = "a"
│ │ ├── name_loc: (8,0)-(8,1) = "a"
│ │ ├── value:
│ │ │ @ IntegerNode (location: (93...94))
│ │ │ @ IntegerNode (location: (8,4)-(8,5))
│ │ │ └── flags: decimal
│ │ └── operator_loc: (91...92) = "="
│ ├── end_keyword_loc: (95...98) = "end"
│ │ └── operator_loc: (8,2)-(8,3) = "="
│ ├── end_keyword_loc: (9,0)-(9,3) = "end"
│ └── name: :A
├── @ SingletonClassNode (location: (100...120))
├── @ SingletonClassNode (location: (11,0)-(12,3))
│ ├── locals: []
│ ├── class_keyword_loc: (100...105) = "class"
│ ├── operator_loc: (106...108) = "<<"
│ ├── class_keyword_loc: (11,0)-(11,5) = "class"
│ ├── operator_loc: (11,6)-(11,8) = "<<"
│ ├── expression:
│ │ @ CallNode (location: (109...116))
│ │ @ CallNode (location: (11,9)-(11,16))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (113...116))
│ │ │ @ CallNode (location: (11,13)-(11,16))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (113...116) = "foo"
│ │ │ ├── message_loc: (11,13)-(11,16) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -120,7 +120,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (109...112) = "not"
│ │ ├── message_loc: (11,9)-(11,12) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -128,101 +128,101 @@
│ │ ├── flags: ∅
│ │ └── name: "!"
│ ├── body: ∅
│ └── end_keyword_loc: (117...120) = "end"
├── @ ClassNode (location: (122...162))
│ └── end_keyword_loc: (12,0)-(12,3) = "end"
├── @ ClassNode (location: (14,0)-(14,40))
│ ├── locals: []
│ ├── class_keyword_loc: (122...127) = "class"
│ ├── class_keyword_loc: (14,0)-(14,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (128...129))
│ │ @ ConstantReadNode (location: (14,6)-(14,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (131...157))
│ │ @ StatementsNode (location: (14,9)-(14,35))
│ │ └── body: (length: 1)
│ │ └── @ SingletonClassNode (location: (131...157))
│ │ └── @ SingletonClassNode (location: (14,9)-(14,35))
│ │ ├── locals: []
│ │ ├── class_keyword_loc: (131...136) = "class"
│ │ ├── operator_loc: (137...139) = "<<"
│ │ ├── class_keyword_loc: (14,9)-(14,14) = "class"
│ │ ├── operator_loc: (14,15)-(14,17) = "<<"
│ │ ├── expression:
│ │ │ @ SelfNode (location: (140...144))
│ │ │ @ SelfNode (location: (14,18)-(14,22))
│ │ ├── body:
│ │ │ @ BeginNode (location: (146...157))
│ │ │ @ BeginNode (location: (14,24)-(14,35))
│ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause: ∅
│ │ │ ├── else_clause: ∅
│ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (146...157))
│ │ │ │ ├── ensure_keyword_loc: (146...152) = "ensure"
│ │ │ │ @ EnsureNode (location: (14,24)-(14,35))
│ │ │ │ ├── ensure_keyword_loc: (14,24)-(14,30) = "ensure"
│ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (154...157) = "end"
│ │ │ └── end_keyword_loc: (154...157) = "end"
│ │ └── end_keyword_loc: (154...157) = "end"
│ ├── end_keyword_loc: (159...162) = "end"
│ │ │ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ │ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ │ └── end_keyword_loc: (14,32)-(14,35) = "end"
│ ├── end_keyword_loc: (14,37)-(14,40) = "end"
│ └── name: :A
├── @ ClassNode (location: (164...218))
├── @ ClassNode (location: (16,0)-(16,54))
│ ├── locals: []
│ ├── class_keyword_loc: (164...169) = "class"
│ ├── class_keyword_loc: (16,0)-(16,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (170...171))
│ │ @ ConstantReadNode (location: (16,6)-(16,7))
│ │ └── name: :A
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (173...213))
│ │ @ StatementsNode (location: (16,9)-(16,49))
│ │ └── body: (length: 1)
│ │ └── @ SingletonClassNode (location: (173...213))
│ │ └── @ SingletonClassNode (location: (16,9)-(16,49))
│ │ ├── locals: []
│ │ ├── class_keyword_loc: (173...178) = "class"
│ │ ├── operator_loc: (179...181) = "<<"
│ │ ├── class_keyword_loc: (16,9)-(16,14) = "class"
│ │ ├── operator_loc: (16,15)-(16,17) = "<<"
│ │ ├── expression:
│ │ │ @ SelfNode (location: (182...186))
│ │ │ @ SelfNode (location: (16,18)-(16,22))
│ │ ├── body:
│ │ │ @ BeginNode (location: (188...213))
│ │ │ @ BeginNode (location: (16,24)-(16,49))
│ │ │ ├── begin_keyword_loc: ∅
│ │ │ ├── statements: ∅
│ │ │ ├── rescue_clause:
│ │ │ │ @ RescueNode (location: (188...194))
│ │ │ │ ├── keyword_loc: (188...194) = "rescue"
│ │ │ │ @ RescueNode (location: (16,24)-(16,30))
│ │ │ │ ├── keyword_loc: (16,24)-(16,30) = "rescue"
│ │ │ │ ├── exceptions: (length: 0)
│ │ │ │ ├── operator_loc: ∅
│ │ │ │ ├── reference: ∅
│ │ │ │ ├── statements: ∅
│ │ │ │ └── consequent: ∅
│ │ │ ├── else_clause:
│ │ │ │ @ ElseNode (location: (196...208))
│ │ │ │ ├── else_keyword_loc: (196...200) = "else"
│ │ │ │ @ ElseNode (location: (16,32)-(16,44))
│ │ │ │ ├── else_keyword_loc: (16,32)-(16,36) = "else"
│ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (202...208) = "ensure"
│ │ │ │ └── end_keyword_loc: (16,38)-(16,44) = "ensure"
│ │ │ ├── ensure_clause:
│ │ │ │ @ EnsureNode (location: (202...213))
│ │ │ │ ├── ensure_keyword_loc: (202...208) = "ensure"
│ │ │ │ @ EnsureNode (location: (16,38)-(16,49))
│ │ │ │ ├── ensure_keyword_loc: (16,38)-(16,44) = "ensure"
│ │ │ │ ├── statements: ∅
│ │ │ │ └── end_keyword_loc: (210...213) = "end"
│ │ │ └── end_keyword_loc: (210...213) = "end"
│ │ └── end_keyword_loc: (210...213) = "end"
│ ├── end_keyword_loc: (215...218) = "end"
│ │ │ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ │ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ │ └── end_keyword_loc: (16,46)-(16,49) = "end"
│ ├── end_keyword_loc: (16,51)-(16,54) = "end"
│ └── name: :A
├── @ SingletonClassNode (location: (220...240))
├── @ SingletonClassNode (location: (18,0)-(19,3))
│ ├── locals: []
│ ├── class_keyword_loc: (220...225) = "class"
│ ├── operator_loc: (226...228) = "<<"
│ ├── class_keyword_loc: (18,0)-(18,5) = "class"
│ ├── operator_loc: (18,6)-(18,8) = "<<"
│ ├── expression:
│ │ @ CallNode (location: (229...236))
│ │ @ CallNode (location: (18,9)-(18,16))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (229...232))
│ │ │ @ CallNode (location: (18,9)-(18,12))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (229...232) = "foo"
│ │ │ ├── message_loc: (18,9)-(18,12) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: (232...233) = "."
│ │ ├── message_loc: (233...236) = "bar"
│ │ ├── call_operator_loc: (18,12)-(18,13) = "."
│ │ ├── message_loc: (18,13)-(18,16) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -230,26 +230,26 @@
│ │ ├── flags: ∅
│ │ └── name: "bar"
│ ├── body: ∅
│ └── end_keyword_loc: (237...240) = "end"
├── @ SingletonClassNode (location: (242...262))
│ └── end_keyword_loc: (19,0)-(19,3) = "end"
├── @ SingletonClassNode (location: (21,0)-(21,20))
│ ├── locals: []
│ ├── class_keyword_loc: (242...247) = "class"
│ ├── operator_loc: (248...250) = "<<"
│ ├── class_keyword_loc: (21,0)-(21,5) = "class"
│ ├── operator_loc: (21,6)-(21,8) = "<<"
│ ├── expression:
│ │ @ CallNode (location: (251...258))
│ │ @ CallNode (location: (21,9)-(21,16))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (251...254))
│ │ │ @ CallNode (location: (21,9)-(21,12))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (251...254) = "foo"
│ │ │ ├── message_loc: (21,9)-(21,12) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: (254...255) = "."
│ │ ├── message_loc: (255...258) = "bar"
│ │ ├── call_operator_loc: (21,12)-(21,13) = "."
│ │ ├── message_loc: (21,13)-(21,16) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -257,99 +257,99 @@
│ │ ├── flags: ∅
│ │ └── name: "bar"
│ ├── body: ∅
│ └── end_keyword_loc: (259...262) = "end"
├── @ SingletonClassNode (location: (264...281))
│ └── end_keyword_loc: (21,17)-(21,20) = "end"
├── @ SingletonClassNode (location: (23,0)-(24,3))
│ ├── locals: []
│ ├── class_keyword_loc: (264...269) = "class"
│ ├── operator_loc: (270...272) = "<<"
│ ├── class_keyword_loc: (23,0)-(23,5) = "class"
│ ├── operator_loc: (23,6)-(23,8) = "<<"
│ ├── expression:
│ │ @ SelfNode (location: (273...277))
│ │ @ SelfNode (location: (23,9)-(23,13))
│ ├── body: ∅
│ └── end_keyword_loc: (278...281) = "end"
├── @ SingletonClassNode (location: (283...300))
│ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ SingletonClassNode (location: (26,0)-(26,17))
│ ├── locals: []
│ ├── class_keyword_loc: (283...288) = "class"
│ ├── operator_loc: (289...291) = "<<"
│ ├── class_keyword_loc: (26,0)-(26,5) = "class"
│ ├── operator_loc: (26,6)-(26,8) = "<<"
│ ├── expression:
│ │ @ SelfNode (location: (292...296))
│ │ @ SelfNode (location: (26,9)-(26,13))
│ ├── body: ∅
│ └── end_keyword_loc: (297...300) = "end"
├── @ SingletonClassNode (location: (302...325))
│ └── end_keyword_loc: (26,14)-(26,17) = "end"
├── @ SingletonClassNode (location: (28,0)-(30,3))
│ ├── locals: []
│ ├── class_keyword_loc: (302...307) = "class"
│ ├── operator_loc: (308...310) = "<<"
│ ├── class_keyword_loc: (28,0)-(28,5) = "class"
│ ├── operator_loc: (28,6)-(28,8) = "<<"
│ ├── expression:
│ │ @ SelfNode (location: (311...315))
│ │ @ SelfNode (location: (28,9)-(28,13))
│ ├── body:
│ │ @ StatementsNode (location: (316...321))
│ │ @ StatementsNode (location: (29,0)-(29,5))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (316...321))
│ │ └── @ CallNode (location: (29,0)-(29,5))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (316...317))
│ │ │ @ IntegerNode (location: (29,0)-(29,1))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (318...319) = "+"
│ │ ├── message_loc: (29,2)-(29,3) = "+"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (320...321))
│ │ │ @ ArgumentsNode (location: (29,4)-(29,5))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (320...321))
│ │ │ └── @ IntegerNode (location: (29,4)-(29,5))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "+"
│ └── end_keyword_loc: (322...325) = "end"
├── @ SingletonClassNode (location: (327...350))
│ └── end_keyword_loc: (30,0)-(30,3) = "end"
├── @ SingletonClassNode (location: (32,0)-(32,23))
│ ├── locals: []
│ ├── class_keyword_loc: (327...332) = "class"
│ ├── operator_loc: (333...335) = "<<"
│ ├── class_keyword_loc: (32,0)-(32,5) = "class"
│ ├── operator_loc: (32,6)-(32,8) = "<<"
│ ├── expression:
│ │ @ SelfNode (location: (336...340))
│ │ @ SelfNode (location: (32,9)-(32,13))
│ ├── body:
│ │ @ StatementsNode (location: (341...346))
│ │ @ StatementsNode (location: (32,14)-(32,19))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (341...346))
│ │ └── @ CallNode (location: (32,14)-(32,19))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (341...342))
│ │ │ @ IntegerNode (location: (32,14)-(32,15))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (343...344) = "+"
│ │ ├── message_loc: (32,16)-(32,17) = "+"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (345...346))
│ │ │ @ ArgumentsNode (location: (32,18)-(32,19))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (345...346))
│ │ │ └── @ IntegerNode (location: (32,18)-(32,19))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "+"
│ └── end_keyword_loc: (347...350) = "end"
└── @ ClassNode (location: (352...370))
│ └── end_keyword_loc: (32,20)-(32,23) = "end"
└── @ ClassNode (location: (34,0)-(35,3))
├── locals: []
├── class_keyword_loc: (352...357) = "class"
├── class_keyword_loc: (34,0)-(34,5) = "class"
├── constant_path:
│ @ ConstantReadNode (location: (358...359))
│ @ ConstantReadNode (location: (34,6)-(34,7))
│ └── name: :A
├── inheritance_operator_loc: (360...361) = "<"
├── inheritance_operator_loc: (34,8)-(34,9) = "<"
├── superclass:
│ @ CallNode (location: (362...366))
│ @ CallNode (location: (34,10)-(34,14))
│ ├── receiver:
│ │ @ ConstantReadNode (location: (362...363))
│ │ @ ConstantReadNode (location: (34,10)-(34,11))
│ │ └── name: :B
│ ├── call_operator_loc: ∅
│ ├── message_loc: (363...366) = "[1]"
│ ├── opening_loc: (363...364) = "["
│ ├── message_loc: (34,11)-(34,14) = "[1]"
│ ├── opening_loc: (34,11)-(34,12) = "["
│ ├── arguments:
│ │ @ ArgumentsNode (location: (364...365))
│ │ @ ArgumentsNode (location: (34,12)-(34,13))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (364...365))
│ │ └── @ IntegerNode (location: (34,12)-(34,13))
│ │ └── flags: decimal
│ ├── closing_loc: (365...366) = "]"
│ ├── closing_loc: (34,13)-(34,14) = "]"
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "[]"
├── body: ∅
├── end_keyword_loc: (367...370) = "end"
├── end_keyword_loc: (35,0)-(35,3) = "end"
└── 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: []
└── statements:
@ StatementsNode (location: (0...118))
@ StatementsNode (location: (1,0)-(24,5))
└── body: (length: 9)
├── @ CallNode (location: (0...1))
├── @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a"
│ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "a"
├── @ CallNode (location: (13...14))
├── @ CallNode (location: (3,0)-(3,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (13...14) = "b"
│ ├── message_loc: (3,0)-(3,1) = "b"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "b"
├── @ CallNode (location: (16...17))
├── @ CallNode (location: (5,0)-(5,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (16...17) = "c"
│ ├── message_loc: (5,0)-(5,1) = "c"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "c"
├── @ CallNode (location: (28...29))
├── @ CallNode (location: (6,0)-(6,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (28...29) = "d"
│ ├── message_loc: (6,0)-(6,1) = "d"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "d"
├── @ CallNode (location: (31...47))
├── @ CallNode (location: (8,0)-(10,4))
│ ├── receiver:
│ │ @ CallNode (location: (31...32))
│ │ @ CallNode (location: (8,0)-(8,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (31...32) = "e"
│ │ ├── message_loc: (8,0)-(8,1) = "e"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "e"
│ ├── call_operator_loc: (45...46) = "."
│ ├── message_loc: (46...47) = "f"
│ ├── call_operator_loc: (10,2)-(10,3) = "."
│ ├── message_loc: (10,3)-(10,4) = "f"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "f"
├── @ CallNode (location: (49...64))
├── @ CallNode (location: (12,0)-(14,2))
│ ├── receiver:
│ │ @ CallNode (location: (49...50))
│ │ @ CallNode (location: (12,0)-(12,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (49...50) = "g"
│ │ ├── message_loc: (12,0)-(12,1) = "g"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "g"
│ ├── call_operator_loc: (62...63) = "."
│ ├── message_loc: (63...64) = "h"
│ ├── call_operator_loc: (14,0)-(14,1) = "."
│ ├── message_loc: (14,1)-(14,2) = "h"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "h"
├── @ CallNode (location: (66...80))
├── @ CallNode (location: (16,0)-(17,2))
│ ├── receiver:
│ │ @ CallNode (location: (66...67))
│ │ @ CallNode (location: (16,0)-(16,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (66...67) = "i"
│ │ ├── message_loc: (16,0)-(16,1) = "i"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "i"
│ ├── call_operator_loc: (78...79) = "."
│ ├── message_loc: (79...80) = "j"
│ ├── call_operator_loc: (17,0)-(17,1) = "."
│ ├── message_loc: (17,1)-(17,2) = "j"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "j"
├── @ CallNode (location: (82...98))
├── @ CallNode (location: (19,0)-(20,4))
│ ├── receiver:
│ │ @ CallNode (location: (82...83))
│ │ @ CallNode (location: (19,0)-(19,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (82...83) = "k"
│ │ ├── message_loc: (19,0)-(19,1) = "k"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "k"
│ ├── call_operator_loc: (96...97) = "."
│ ├── message_loc: (97...98) = "l"
│ ├── call_operator_loc: (20,2)-(20,3) = "."
│ ├── message_loc: (20,3)-(20,4) = "l"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "l"
└── @ CallNode (location: (100...118))
└── @ CallNode (location: (22,0)-(24,5))
├── receiver:
│ @ CallNode (location: (100...101))
│ @ CallNode (location: (22,0)-(22,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (100...101) = "m"
│ ├── message_loc: (22,0)-(22,1) = "m"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "m"
├── call_operator_loc: (115...117) = "&."
├── message_loc: (117...118) = "n"
├── call_operator_loc: (24,2)-(24,4) = "&."
├── message_loc: (24,4)-(24,5) = "n"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...278))
@ StatementsNode (location: (1,0)-(57,11))
└── body: (length: 13)
├── @ StringNode (location: (0...6))
├── @ StringNode (location: (1,0)-(1,6))
│ ├── flags: ∅
│ ├── opening_loc: (0...6) = "<<-EOF"
│ ├── content_loc: (7...11) = " a\n"
│ ├── closing_loc: (11...15) = "EOF\n"
│ ├── opening_loc: (1,0)-(1,6) = "<<-EOF"
│ ├── content_loc: (2,0)-(2,0) = " a\n"
│ ├── closing_loc: (3,0)-(3,0) = "EOF\n"
│ └── unescaped: " a\n"
├── @ CallNode (location: (16...36))
├── @ CallNode (location: (5,0)-(5,20))
│ ├── receiver:
│ │ @ StringNode (location: (16...24))
│ │ @ StringNode (location: (5,0)-(5,8))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (16...24) = "<<-FIRST"
│ │ ├── content_loc: (37...41) = " a\n"
│ │ ├── closing_loc: (41...47) = "FIRST\n"
│ │ ├── opening_loc: (5,0)-(5,8) = "<<-FIRST"
│ │ ├── content_loc: (6,0)-(6,0) = " a\n"
│ │ ├── closing_loc: (7,0)-(7,0) = "FIRST\n"
│ │ └── unescaped: " a\n"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (25...26) = "+"
│ ├── message_loc: (5,9)-(5,10) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (27...36))
│ │ @ ArgumentsNode (location: (5,11)-(5,20))
│ │ └── arguments: (length: 1)
│ │ └── @ StringNode (location: (27...36))
│ │ └── @ StringNode (location: (5,11)-(5,20))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (27...36) = "<<-SECOND"
│ │ ├── content_loc: (47...51) = " b\n"
│ │ ├── closing_loc: (51...58) = "SECOND\n"
│ │ ├── opening_loc: (5,11)-(5,20) = "<<-SECOND"
│ │ ├── content_loc: (8,0)-(8,0) = " b\n"
│ │ ├── closing_loc: (9,0)-(9,0) = "SECOND\n"
│ │ └── unescaped: " b\n"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
├── @ InterpolatedXStringNode (location: (59...67))
│ ├── opening_loc: (59...67) = "<<-`EOF`"
├── @ InterpolatedXStringNode (location: (11,0)-(11,8))
│ ├── opening_loc: (11,0)-(11,8) = "<<-`EOF`"
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (68...72))
│ │ ├── @ StringNode (location: (12,0)-(12,0))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (68...72) = " a\n"
│ │ │ ├── content_loc: (12,0)-(12,0) = " a\n"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (72...76))
│ │ │ ├── opening_loc: (72...74) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (13,0)-(13,4))
│ │ │ ├── opening_loc: (13,0)-(13,2) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (74...75))
│ │ │ │ @ StatementsNode (location: (13,2)-(13,3))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (74...75))
│ │ │ │ └── @ CallNode (location: (13,2)-(13,3))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (74...75) = "b"
│ │ │ │ ├── message_loc: (13,2)-(13,3) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (75...76) = "}"
│ │ └── @ StringNode (location: (76...77))
│ │ │ └── closing_loc: (13,3)-(13,4) = "}"
│ │ └── @ StringNode (location: (13,4)-(13,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (76...77) = "\n"
│ │ ├── content_loc: (13,4)-(13,0) = "\n"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n"
│ └── closing_loc: (77...81) = "EOF\n"
├── @ StringNode (location: (82...88))
│ └── closing_loc: (14,0)-(14,0) = "EOF\n"
├── @ StringNode (location: (16,0)-(16,6))
│ ├── flags: ∅
│ ├── opening_loc: (82...88) = "<<-EOF"
│ ├── content_loc: (98...102) = " a\n"
│ ├── closing_loc: (102...106) = "EOF\n"
│ ├── opening_loc: (16,0)-(16,6) = "<<-EOF"
│ ├── content_loc: (17,0)-(17,0) = " a\n"
│ ├── closing_loc: (18,0)-(18,0) = "EOF\n"
│ └── unescaped: " a\n"
├── @ StringNode (location: (107...113))
├── @ StringNode (location: (20,0)-(20,6))
│ ├── flags: ∅
│ ├── opening_loc: (107...113) = "<<-EOF"
│ ├── content_loc: (114...122) = " a\n b\n"
│ ├── closing_loc: (122...128) = " EOF\n"
│ ├── opening_loc: (20,0)-(20,6) = "<<-EOF"
│ ├── content_loc: (21,0)-(22,0) = " a\n b\n"
│ ├── closing_loc: (23,0)-(23,0) = " EOF\n"
│ └── unescaped: " a\n b\n"
├── @ InterpolatedStringNode (location: (129...137))
│ ├── opening_loc: (129...137) = "<<-\"EOF\""
├── @ InterpolatedStringNode (location: (25,0)-(25,8))
│ ├── opening_loc: (25,0)-(25,8) = "<<-\"EOF\""
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (138...142))
│ │ ├── @ StringNode (location: (26,0)-(26,0))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (138...142) = " a\n"
│ │ │ ├── content_loc: (26,0)-(26,0) = " a\n"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (142...146))
│ │ │ ├── opening_loc: (142...144) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (27,0)-(27,4))
│ │ │ ├── opening_loc: (27,0)-(27,2) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (144...145))
│ │ │ │ @ StatementsNode (location: (27,2)-(27,3))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (144...145))
│ │ │ │ └── @ CallNode (location: (27,2)-(27,3))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (144...145) = "b"
│ │ │ │ ├── message_loc: (27,2)-(27,3) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (145...146) = "}"
│ │ └── @ StringNode (location: (146...147))
│ │ │ └── closing_loc: (27,3)-(27,4) = "}"
│ │ └── @ StringNode (location: (27,4)-(27,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (146...147) = "\n"
│ │ ├── content_loc: (27,4)-(27,0) = "\n"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n"
│ └── closing_loc: (147...151) = "EOF\n"
├── @ InterpolatedStringNode (location: (152...158))
│ ├── opening_loc: (152...158) = "<<-EOF"
│ └── closing_loc: (28,0)-(28,0) = "EOF\n"
├── @ InterpolatedStringNode (location: (30,0)-(30,6))
│ ├── opening_loc: (30,0)-(30,6) = "<<-EOF"
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (159...163))
│ │ ├── @ StringNode (location: (31,0)-(31,0))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (159...163) = " a\n"
│ │ │ ├── content_loc: (31,0)-(31,0) = " a\n"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " a\n"
│ │ ├── @ EmbeddedStatementsNode (location: (163...167))
│ │ │ ├── opening_loc: (163...165) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (32,0)-(32,4))
│ │ │ ├── opening_loc: (32,0)-(32,2) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (165...166))
│ │ │ │ @ StatementsNode (location: (32,2)-(32,3))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (165...166))
│ │ │ │ └── @ CallNode (location: (32,2)-(32,3))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (165...166) = "b"
│ │ │ │ ├── message_loc: (32,2)-(32,3) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── closing_loc: (166...167) = "}"
│ │ └── @ StringNode (location: (167...168))
│ │ │ └── closing_loc: (32,3)-(32,4) = "}"
│ │ └── @ StringNode (location: (32,4)-(32,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (167...168) = "\n"
│ │ ├── content_loc: (32,4)-(32,0) = "\n"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n"
│ └── closing_loc: (168...172) = "EOF\n"
├── @ StringNode (location: (173...179))
│ └── closing_loc: (33,0)-(33,0) = "EOF\n"
├── @ StringNode (location: (35,0)-(35,6))
│ ├── flags: ∅
│ ├── opening_loc: (173...175) = "%#"
│ ├── content_loc: (175...178) = "abc"
│ ├── closing_loc: (178...179) = "#"
│ ├── opening_loc: (35,0)-(35,2) = "%#"
│ ├── content_loc: (35,2)-(35,5) = "abc"
│ ├── closing_loc: (35,5)-(35,6) = "#"
│ └── unescaped: "abc"
├── @ StringNode (location: (181...187))
├── @ StringNode (location: (37,0)-(37,6))
│ ├── flags: ∅
│ ├── opening_loc: (181...187) = "<<-EOF"
│ ├── content_loc: (188...196) = " a\n b\n"
│ ├── closing_loc: (196...200) = "EOF\n"
│ ├── opening_loc: (37,0)-(37,6) = "<<-EOF"
│ ├── content_loc: (38,0)-(39,0) = " a\n b\n"
│ ├── closing_loc: (40,0)-(40,0) = "EOF\n"
│ └── unescaped: " a\n b\n"
├── @ StringNode (location: (201...206))
├── @ StringNode (location: (42,0)-(42,5))
│ ├── flags: ∅
│ ├── opening_loc: (201...206) = "<<-''"
│ ├── content_loc: (207...207) = ""
│ ├── closing_loc: (207...208) = "\n"
│ ├── opening_loc: (42,0)-(42,5) = "<<-''"
│ ├── content_loc: (43,0)-(42,0) = ""
│ ├── closing_loc: (43,0)-(43,0) = "\n"
│ └── unescaped: ""
├── @ StringNode (location: (209...217))
├── @ StringNode (location: (45,0)-(45,8))
│ ├── flags: ∅
│ ├── opening_loc: (209...217) = "<<-'EOF'"
│ ├── content_loc: (218...227) = " a \#{1}\n"
│ ├── closing_loc: (227...231) = "EOF\n"
│ ├── opening_loc: (45,0)-(45,8) = "<<-'EOF'"
│ ├── content_loc: (46,0)-(46,0) = " a \#{1}\n"
│ ├── closing_loc: (47,0)-(47,0) = "EOF\n"
│ └── unescaped: " a \#{1}\n"
├── @ CallNode (location: (232...243))
├── @ CallNode (location: (49,0)-(49,11))
│ ├── receiver:
│ │ @ StringNode (location: (232...236))
│ │ @ StringNode (location: (49,0)-(49,4))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (232...236) = "<<-A"
│ │ ├── content_loc: (244...248) = " a\n"
│ │ ├── closing_loc: (248...250) = "A\n"
│ │ ├── opening_loc: (49,0)-(49,4) = "<<-A"
│ │ ├── content_loc: (50,0)-(50,0) = " a\n"
│ │ ├── closing_loc: (51,0)-(51,0) = "A\n"
│ │ └── unescaped: " a\n"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (237...238) = "+"
│ ├── message_loc: (49,5)-(49,6) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (239...243))
│ │ @ ArgumentsNode (location: (49,7)-(49,11))
│ │ └── arguments: (length: 1)
│ │ └── @ InterpolatedStringNode (location: (239...243))
│ │ ├── opening_loc: (239...243) = "<<-B"
│ │ └── @ InterpolatedStringNode (location: (49,7)-(49,11))
│ │ ├── opening_loc: (49,7)-(49,11) = "<<-B"
│ │ ├── parts: (length: 3)
│ │ │ ├── @ StringNode (location: (250...256))
│ │ │ ├── @ StringNode (location: (52,0)-(53,2))
│ │ │ │ ├── flags: ∅
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── content_loc: (250...256) = " b\n "
│ │ │ │ ├── content_loc: (52,0)-(53,2) = " b\n "
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: " b\n "
│ │ │ ├── @ EmbeddedStatementsNode (location: (256...263))
│ │ │ │ ├── opening_loc: (256...258) = "\#{"
│ │ │ ├── @ EmbeddedStatementsNode (location: (53,2)-(54,3))
│ │ │ │ ├── opening_loc: (53,2)-(53,4) = "\#{"
│ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (258...259))
│ │ │ │ │ @ StatementsNode (location: (53,4)-(53,5))
│ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (258...259))
│ │ │ │ │ └── @ IntegerNode (location: (53,4)-(53,5))
│ │ │ │ │ └── flags: decimal
│ │ │ │ └── closing_loc: (262...263) = "}"
│ │ │ └── @ StringNode (location: (263...264))
│ │ │ │ └── closing_loc: (54,2)-(54,3) = "}"
│ │ │ └── @ StringNode (location: (54,3)-(54,0))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (263...264) = "\n"
│ │ │ ├── content_loc: (54,3)-(54,0) = "\n"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "\n"
│ │ └── closing_loc: (264...266) = "B\n"
│ │ └── closing_loc: (55,0)-(55,0) = "B\n"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
└── @ CallNode (location: (267...278))
└── @ CallNode (location: (57,0)-(57,11))
├── receiver:
│ @ StringNode (location: (267...271))
│ @ StringNode (location: (57,0)-(57,4))
│ ├── flags: ∅
│ ├── opening_loc: (267...271) = "<<-A"
│ ├── content_loc: (279...283) = " a\n"
│ ├── closing_loc: (283...285) = "A\n"
│ ├── opening_loc: (57,0)-(57,4) = "<<-A"
│ ├── content_loc: (58,0)-(58,0) = " a\n"
│ ├── closing_loc: (59,0)-(59,0) = "A\n"
│ └── unescaped: " a\n"
├── call_operator_loc: ∅
├── message_loc: (272...273) = "+"
├── message_loc: (57,5)-(57,6) = "+"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (274...278))
│ @ ArgumentsNode (location: (57,7)-(57,11))
│ └── arguments: (length: 1)
│ └── @ InterpolatedStringNode (location: (274...278))
│ ├── opening_loc: (274...278) = "<<-B"
│ └── @ InterpolatedStringNode (location: (57,7)-(57,11))
│ ├── opening_loc: (57,7)-(57,11) = "<<-B"
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (285...291))
│ │ ├── @ StringNode (location: (60,0)-(61,2))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (285...291) = " b\n "
│ │ │ ├── content_loc: (60,0)-(61,2) = " b\n "
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: " b\n "
│ │ ├── @ EmbeddedStatementsNode (location: (291...298))
│ │ │ ├── opening_loc: (291...293) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (61,2)-(62,4))
│ │ │ ├── opening_loc: (61,2)-(61,4) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (296...297))
│ │ │ │ @ StatementsNode (location: (62,2)-(62,3))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (296...297))
│ │ │ │ └── @ IntegerNode (location: (62,2)-(62,3))
│ │ │ │ └── flags: decimal
│ │ │ └── closing_loc: (297...298) = "}"
│ │ └── @ StringNode (location: (298...299))
│ │ │ └── closing_loc: (62,3)-(62,4) = "}"
│ │ └── @ StringNode (location: (62,4)-(62,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (298...299) = "\n"
│ │ ├── content_loc: (62,4)-(62,0) = "\n"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "\n"
│ └── closing_loc: (299...301) = "B\n"
│ └── closing_loc: (63,0)-(63,0) = "B\n"
├── closing_loc: ∅
├── block: ∅
├── 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]
└── statements:
@ StatementsNode (location: (0...78))
@ StatementsNode (location: (1,0)-(7,10))
└── body: (length: 4)
├── @ AndNode (location: (0...25))
├── @ AndNode (location: (1,0)-(1,25))
│ ├── left:
│ │ @ DefinedNode (location: (0...10))
│ │ @ DefinedNode (location: (1,0)-(1,10))
│ │ ├── lparen_loc: ∅
│ │ ├── value:
│ │ │ @ IntegerNode (location: (9...10))
│ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ └── flags: decimal
│ │ ├── rparen_loc: ∅
│ │ └── keyword_loc: (0...8) = "defined?"
│ │ └── keyword_loc: (1,0)-(1,8) = "defined?"
│ ├── right:
│ │ @ DefinedNode (location: (15...25))
│ │ @ DefinedNode (location: (1,15)-(1,25))
│ │ ├── lparen_loc: ∅
│ │ ├── value:
│ │ │ @ IntegerNode (location: (24...25))
│ │ │ @ IntegerNode (location: (1,24)-(1,25))
│ │ │ └── flags: decimal
│ │ ├── rparen_loc: ∅
│ │ └── keyword_loc: (15...23) = "defined?"
│ └── operator_loc: (11...14) = "and"
├── @ DefinedNode (location: (27...43))
│ ├── lparen_loc: (35...36) = "("
│ │ └── keyword_loc: (1,15)-(1,23) = "defined?"
│ └── operator_loc: (1,11)-(1,14) = "and"
├── @ DefinedNode (location: (3,0)-(3,16))
│ ├── lparen_loc: (3,8)-(3,9) = "("
│ ├── value:
│ │ @ LocalVariableOperatorWriteNode (location: (36...42))
│ │ ├── name_loc: (36...37) = "x"
│ │ ├── operator_loc: (38...40) = "%="
│ │ @ LocalVariableOperatorWriteNode (location: (3,9)-(3,15))
│ │ ├── name_loc: (3,9)-(3,10) = "x"
│ │ ├── operator_loc: (3,11)-(3,13) = "%="
│ │ ├── value:
│ │ │ @ IntegerNode (location: (41...42))
│ │ │ @ IntegerNode (location: (3,14)-(3,15))
│ │ │ └── flags: decimal
│ │ ├── name: :x
│ │ ├── operator: :%
│ │ └── depth: 0
│ ├── rparen_loc: (42...43) = ")"
│ └── keyword_loc: (27...35) = "defined?"
├── @ DefinedNode (location: (45...66))
│ ├── lparen_loc: (53...54) = "("
│ ├── rparen_loc: (3,15)-(3,16) = ")"
│ └── keyword_loc: (3,0)-(3,8) = "defined?"
├── @ DefinedNode (location: (5,0)-(5,21))
│ ├── lparen_loc: (5,8)-(5,9) = "("
│ ├── value:
│ │ @ AndNode (location: (54...65))
│ │ @ AndNode (location: (5,9)-(5,20))
│ │ ├── left:
│ │ │ @ CallNode (location: (54...57))
│ │ │ @ CallNode (location: (5,9)-(5,12))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (54...57) = "foo"
│ │ │ ├── message_loc: (5,9)-(5,12) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -51,23 +51,23 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── right:
│ │ │ @ CallNode (location: (62...65))
│ │ │ @ CallNode (location: (5,17)-(5,20))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (62...65) = "bar"
│ │ │ ├── message_loc: (5,17)-(5,20) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ └── operator_loc: (58...61) = "and"
│ ├── rparen_loc: (65...66) = ")"
│ └── keyword_loc: (45...53) = "defined?"
└── @ DefinedNode (location: (68...78))
│ │ └── operator_loc: (5,13)-(5,16) = "and"
│ ├── rparen_loc: (5,20)-(5,21) = ")"
│ └── keyword_loc: (5,0)-(5,8) = "defined?"
└── @ DefinedNode (location: (7,0)-(7,10))
├── lparen_loc: ∅
├── value:
│ @ IntegerNode (location: (77...78))
│ @ IntegerNode (location: (7,9)-(7,10))
│ └── flags: decimal
├── 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]
└── statements:
@ StatementsNode (location: (0...108))
@ StatementsNode (location: (1,0)-(17,20))
└── body: (length: 5)
├── @ CallNode (location: (0...24))
├── @ CallNode (location: (1,0)-(2,12))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...4) = "puts"
│ ├── message_loc: (1,0)-(1,4) = "puts"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (5...24))
│ │ @ ArgumentsNode (location: (1,5)-(2,12))
│ │ └── arguments: (length: 1)
│ │ └── @ StringConcatNode (location: (5...24))
│ │ └── @ StringConcatNode (location: (1,5)-(2,12))
│ │ ├── left:
│ │ │ @ StringNode (location: (5...9))
│ │ │ @ StringNode (location: (1,5)-(1,9))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (5...6) = "\""
│ │ │ ├── content_loc: (6...8) = "hi"
│ │ │ ├── closing_loc: (8...9) = "\""
│ │ │ ├── opening_loc: (1,5)-(1,6) = "\""
│ │ │ ├── content_loc: (1,6)-(1,8) = "hi"
│ │ │ ├── closing_loc: (1,8)-(1,9) = "\""
│ │ │ └── unescaped: "hi"
│ │ └── right:
│ │ @ StringNode (location: (17...24))
│ │ @ StringNode (location: (2,5)-(2,12))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (17...18) = "\""
│ │ ├── content_loc: (18...23) = "there"
│ │ ├── closing_loc: (23...24) = "\""
│ │ ├── opening_loc: (2,5)-(2,6) = "\""
│ │ ├── content_loc: (2,6)-(2,11) = "there"
│ │ ├── closing_loc: (2,11)-(2,12) = "\""
│ │ └── unescaped: "there"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "puts"
├── @ ArrayNode (location: (28...37))
├── @ ArrayNode (location: (4,0)-(5,2))
│ ├── elements: (length: 1)
│ │ └── @ SymbolNode (location: (31...36))
│ │ └── @ SymbolNode (location: (4,3)-(5,1))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (31...36) = "a\\\r\nb"
│ │ ├── value_loc: (4,3)-(5,1) = "a\\\r\nb"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "ab"
│ ├── opening_loc: (28...31) = "%I{"
│ └── closing_loc: (36...37) = "}"
├── @ StringNode (location: (41...45))
│ ├── opening_loc: (4,0)-(4,3) = "%I{"
│ └── closing_loc: (5,1)-(5,2) = "}"
├── @ StringNode (location: (7,0)-(7,4))
│ ├── flags: ∅
│ ├── opening_loc: (41...45) = "<<-E"
│ ├── content_loc: (47...70) = " 1 \\\r\n 2\r\n 3\r\n"
│ ├── closing_loc: (70...73) = "E\r\n"
│ ├── opening_loc: (7,0)-(7,4) = "<<-E"
│ ├── content_loc: (8,0)-(10,0) = " 1 \\\r\n 2\r\n 3\r\n"
│ ├── closing_loc: (11,0)-(11,0) = "E\r\n"
│ └── unescaped: " 1 2\r\n 3\r\n"
├── @ LocalVariableWriteNode (location: (75...84))
├── @ LocalVariableWriteNode (location: (13,0)-(14,0))
│ ├── name: :x
│ ├── depth: 0
│ ├── name_loc: (75...76) = "x"
│ ├── name_loc: (13,0)-(13,1) = "x"
│ ├── value:
│ │ @ StringNode (location: (79...84))
│ │ @ StringNode (location: (13,4)-(14,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (79...82) = "%\r\n"
│ │ ├── content_loc: (82...82) = ""
│ │ ├── closing_loc: (82...84) = "\r\n"
│ │ ├── opening_loc: (13,4)-(13,0) = "%\r\n"
│ │ ├── content_loc: (14,0)-(13,0) = ""
│ │ ├── closing_loc: (14,0)-(14,0) = "\r\n"
│ │ └── unescaped: ""
│ └── operator_loc: (77...78) = "="
└── @ LocalVariableWriteNode (location: (88...108))
│ └── operator_loc: (13,2)-(13,3) = "="
└── @ LocalVariableWriteNode (location: (17,0)-(17,20))
├── name: :a
├── depth: 0
├── name_loc: (88...89) = "a"
├── name_loc: (17,0)-(17,1) = "a"
├── value:
│ @ CallNode (location: (92...108))
│ @ CallNode (location: (17,4)-(17,20))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (92...95) = "foo"
│ ├── opening_loc: (95...96) = "("
│ ├── message_loc: (17,4)-(17,7) = "foo"
│ ├── opening_loc: (17,7)-(17,8) = "("
│ ├── arguments:
│ │ @ ArgumentsNode (location: (96...107))
│ │ @ ArgumentsNode (location: (17,8)-(17,19))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (96...107))
│ │ └── @ CallNode (location: (17,8)-(17,19))
│ │ ├── receiver:
│ │ │ @ StringNode (location: (96...102))
│ │ │ @ StringNode (location: (17,8)-(17,14))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (96...102) = "<<~EOF"
│ │ │ ├── content_loc: (110...121) = "\r\n baz\r\n"
│ │ │ ├── closing_loc: (121...128) = " EOF\r\n"
│ │ │ ├── opening_loc: (17,8)-(17,14) = "<<~EOF"
│ │ │ ├── content_loc: (18,0)-(19,0) = "\r\n baz\r\n"
│ │ │ ├── closing_loc: (20,0)-(20,0) = " EOF\r\n"
│ │ │ └── unescaped: "\nbaz\r\n"
│ │ ├── call_operator_loc: (102...103) = "."
│ │ ├── message_loc: (103...107) = "chop"
│ │ ├── call_operator_loc: (17,14)-(17,15) = "."
│ │ ├── message_loc: (17,15)-(17,19) = "chop"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "chop"
│ ├── closing_loc: (107...108) = ")"
│ ├── closing_loc: (17,19)-(17,20) = ")"
│ ├── block: ∅
│ ├── flags: ∅
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...0))
@ StatementsNode (location: (1,0)-(0,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: []
└── statements:
@ StatementsNode (location: (0...51))
@ StatementsNode (location: (1,0)-(5,22))
└── body: (length: 3)
├── @ DefNode (location: (0...11))
├── @ DefNode (location: (1,0)-(1,11))
│ ├── name: :foo
│ ├── name_loc: (4...7) = "foo"
│ ├── name_loc: (1,4)-(1,7) = "foo"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body:
│ │ @ StatementsNode (location: (10...11))
│ │ @ StatementsNode (location: (1,10)-(1,11))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (10...11))
│ │ └── @ IntegerNode (location: (1,10)-(1,11))
│ │ └── flags: decimal
│ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def"
│ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: (8...9) = "="
│ ├── equal_loc: (1,8)-(1,9) = "="
│ └── end_keyword_loc: ∅
├── @ DefNode (location: (13...27))
├── @ DefNode (location: (3,0)-(3,14))
│ ├── name: :bar
│ ├── name_loc: (17...20) = "bar"
│ ├── name_loc: (3,4)-(3,7) = "bar"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body:
│ │ @ StatementsNode (location: (23...27))
│ │ @ StatementsNode (location: (3,10)-(3,14))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (23...27))
│ │ └── @ CallNode (location: (3,10)-(3,14))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (23...24) = "A"
│ │ ├── message_loc: (3,10)-(3,11) = "A"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (25...27))
│ │ │ @ ArgumentsNode (location: (3,12)-(3,14))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ StringNode (location: (25...27))
│ │ │ └── @ StringNode (location: (3,12)-(3,14))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (25...26) = "\""
│ │ │ ├── content_loc: (26...26) = ""
│ │ │ ├── closing_loc: (26...27) = "\""
│ │ │ ├── opening_loc: (3,12)-(3,13) = "\""
│ │ │ ├── content_loc: (3,13)-(3,13) = ""
│ │ │ ├── closing_loc: (3,13)-(3,14) = "\""
│ │ │ └── unescaped: ""
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "A"
│ ├── locals: []
│ ├── def_keyword_loc: (13...16) = "def"
│ ├── def_keyword_loc: (3,0)-(3,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: (21...22) = "="
│ ├── equal_loc: (3,8)-(3,9) = "="
│ └── end_keyword_loc: ∅
└── @ DefNode (location: (29...51))
└── @ DefNode (location: (5,0)-(5,22))
├── name: :method
├── name_loc: (33...39) = "method"
├── name_loc: (5,4)-(5,10) = "method"
├── receiver: ∅
├── parameters: ∅
├── body:
│ @ StatementsNode (location: (42...51))
│ @ StatementsNode (location: (5,13)-(5,22))
│ └── body: (length: 1)
│ └── @ CallNode (location: (42...51))
│ └── @ CallNode (location: (5,13)-(5,22))
│ ├── receiver:
│ │ @ CallNode (location: (42...47))
│ │ @ CallNode (location: (5,13)-(5,18))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (42...43))
│ │ │ @ IntegerNode (location: (5,13)-(5,14))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (44...45) = "+"
│ │ ├── message_loc: (5,15)-(5,16) = "+"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (46...47))
│ │ │ @ ArgumentsNode (location: (5,17)-(5,18))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (46...47))
│ │ │ └── @ IntegerNode (location: (5,17)-(5,18))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "+"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (48...49) = "+"
│ ├── message_loc: (5,19)-(5,20) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (50...51))
│ │ @ ArgumentsNode (location: (5,21)-(5,22))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (50...51))
│ │ └── @ IntegerNode (location: (5,21)-(5,22))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
├── locals: []
├── def_keyword_loc: (29...32) = "def"
├── def_keyword_loc: (5,0)-(5,3) = "def"
├── operator_loc: ∅
├── lparen_loc: ∅
├── rparen_loc: ∅
├── equal_loc: (40...41) = "="
├── equal_loc: (5,11)-(5,12) = "="
└── 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: []
└── statements:
@ StatementsNode (location: (0...39))
@ StatementsNode (location: (1,0)-(3,12))
└── body: (length: 3)
├── @ IfNode (location: (0...13))
│ ├── if_keyword_loc: (0...2) = "if"
├── @ IfNode (location: (1,0)-(1,13))
│ ├── if_keyword_loc: (1,0)-(1,2) = "if"
│ ├── predicate:
│ │ @ FlipFlopNode (location: (3...7))
│ │ @ FlipFlopNode (location: (1,3)-(1,7))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (3...4))
│ │ │ @ IntegerNode (location: (1,3)-(1,4))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (6...7))
│ │ │ @ IntegerNode (location: (1,6)-(1,7))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (4...6) = ".."
│ │ ├── operator_loc: (1,4)-(1,6) = ".."
│ │ └── flags: ∅
│ ├── statements: ∅
│ ├── consequent: ∅
│ └── end_keyword_loc: (10...13) = "end"
├── @ IfNode (location: (14...26))
│ ├── if_keyword_loc: (14...16) = "if"
│ └── end_keyword_loc: (1,10)-(1,13) = "end"
├── @ IfNode (location: (2,0)-(2,12))
│ ├── if_keyword_loc: (2,0)-(2,2) = "if"
│ ├── predicate:
│ │ @ FlipFlopNode (location: (17...20))
│ │ @ FlipFlopNode (location: (2,3)-(2,6))
│ │ ├── left: ∅
│ │ ├── right:
│ │ │ @ IntegerNode (location: (19...20))
│ │ │ @ IntegerNode (location: (2,5)-(2,6))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (17...19) = ".."
│ │ ├── operator_loc: (2,3)-(2,5) = ".."
│ │ └── flags: ∅
│ ├── statements: ∅
│ ├── consequent: ∅
│ └── end_keyword_loc: (23...26) = "end"
└── @ IfNode (location: (27...39))
├── if_keyword_loc: (27...29) = "if"
│ └── end_keyword_loc: (2,9)-(2,12) = "end"
└── @ IfNode (location: (3,0)-(3,12))
├── if_keyword_loc: (3,0)-(3,2) = "if"
├── predicate:
│ @ FlipFlopNode (location: (30...33))
│ @ FlipFlopNode (location: (3,3)-(3,6))
│ ├── left:
│ │ @ IntegerNode (location: (30...31))
│ │ @ IntegerNode (location: (3,3)-(3,4))
│ │ └── flags: decimal
│ ├── right: ∅
│ ├── operator_loc: (31...33) = ".."
│ ├── operator_loc: (3,4)-(3,6) = ".."
│ └── flags: ∅
├── statements: ∅
├── 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]
└── statements:
@ StatementsNode (location: (0...143))
@ StatementsNode (location: (1,0)-(19,22))
└── body: (length: 6)
├── @ ForNode (location: (0...20))
├── @ ForNode (location: (1,0)-(3,3))
│ ├── index:
│ │ @ LocalVariableTargetNode (location: (4...5))
│ │ @ LocalVariableTargetNode (location: (1,4)-(1,5))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── collection:
│ │ @ RangeNode (location: (9...14))
│ │ @ RangeNode (location: (1,9)-(1,14))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (9...10))
│ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (12...14))
│ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (10...12) = ".."
│ │ ├── operator_loc: (1,10)-(1,12) = ".."
│ │ └── flags: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (15...16))
│ │ @ StatementsNode (location: (2,0)-(2,1))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (15...16))
│ │ └── @ LocalVariableReadNode (location: (2,0)-(2,1))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── for_keyword_loc: (0...3) = "for"
│ ├── in_keyword_loc: (6...8) = "in"
│ ├── for_keyword_loc: (1,0)-(1,3) = "for"
│ ├── in_keyword_loc: (1,6)-(1,8) = "in"
│ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (17...20) = "end"
├── @ ForNode (location: (22...44))
│ └── end_keyword_loc: (3,0)-(3,3) = "end"
├── @ ForNode (location: (5,0)-(5,22))
│ ├── index:
│ │ @ LocalVariableTargetNode (location: (26...27))
│ │ @ LocalVariableTargetNode (location: (5,4)-(5,5))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── collection:
│ │ @ RangeNode (location: (31...36))
│ │ @ RangeNode (location: (5,9)-(5,14))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (31...32))
│ │ │ @ IntegerNode (location: (5,9)-(5,10))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (34...36))
│ │ │ @ IntegerNode (location: (5,12)-(5,14))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (32...34) = ".."
│ │ ├── operator_loc: (5,10)-(5,12) = ".."
│ │ └── flags: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (38...39))
│ │ @ StatementsNode (location: (5,16)-(5,17))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (38...39))
│ │ └── @ LocalVariableReadNode (location: (5,16)-(5,17))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── for_keyword_loc: (22...25) = "for"
│ ├── in_keyword_loc: (28...30) = "in"
│ ├── for_keyword_loc: (5,0)-(5,3) = "for"
│ ├── in_keyword_loc: (5,6)-(5,8) = "in"
│ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (41...44) = "end"
├── @ ForNode (location: (46...68))
│ └── end_keyword_loc: (5,19)-(5,22) = "end"
├── @ ForNode (location: (7,0)-(9,3))
│ ├── index:
│ │ @ MultiTargetNode (location: (50...53))
│ │ @ MultiTargetNode (location: (7,4)-(7,7))
│ │ ├── targets: (length: 2)
│ │ │ ├── @ LocalVariableTargetNode (location: (50...51))
│ │ │ ├── @ LocalVariableTargetNode (location: (7,4)-(7,5))
│ │ │ │ ├── name: :i
│ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableTargetNode (location: (52...53))
│ │ │ └── @ LocalVariableTargetNode (location: (7,6)-(7,7))
│ │ │ ├── name: :j
│ │ │ └── depth: 0
│ │ ├── lparen_loc: ∅
│ │ └── rparen_loc: ∅
│ ├── collection:
│ │ @ RangeNode (location: (57...62))
│ │ @ RangeNode (location: (7,11)-(7,16))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (57...58))
│ │ │ @ IntegerNode (location: (7,11)-(7,12))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (60...62))
│ │ │ @ IntegerNode (location: (7,14)-(7,16))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (58...60) = ".."
│ │ ├── operator_loc: (7,12)-(7,14) = ".."
│ │ └── flags: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (63...64))
│ │ @ StatementsNode (location: (8,0)-(8,1))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (63...64))
│ │ └── @ LocalVariableReadNode (location: (8,0)-(8,1))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── for_keyword_loc: (46...49) = "for"
│ ├── in_keyword_loc: (54...56) = "in"
│ ├── for_keyword_loc: (7,0)-(7,3) = "for"
│ ├── in_keyword_loc: (7,8)-(7,10) = "in"
│ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (65...68) = "end"
├── @ ForNode (location: (70...94))
│ └── end_keyword_loc: (9,0)-(9,3) = "end"
├── @ ForNode (location: (11,0)-(13,3))
│ ├── index:
│ │ @ MultiTargetNode (location: (74...79))
│ │ @ MultiTargetNode (location: (11,4)-(11,9))
│ │ ├── targets: (length: 3)
│ │ │ ├── @ LocalVariableTargetNode (location: (74...75))
│ │ │ ├── @ LocalVariableTargetNode (location: (11,4)-(11,5))
│ │ │ │ ├── name: :i
│ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableTargetNode (location: (76...77))
│ │ │ ├── @ LocalVariableTargetNode (location: (11,6)-(11,7))
│ │ │ │ ├── name: :j
│ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableTargetNode (location: (78...79))
│ │ │ └── @ LocalVariableTargetNode (location: (11,8)-(11,9))
│ │ │ ├── name: :k
│ │ │ └── depth: 0
│ │ ├── lparen_loc: ∅
│ │ └── rparen_loc: ∅
│ ├── collection:
│ │ @ RangeNode (location: (83...88))
│ │ @ RangeNode (location: (11,13)-(11,18))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (83...84))
│ │ │ @ IntegerNode (location: (11,13)-(11,14))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (86...88))
│ │ │ @ IntegerNode (location: (11,16)-(11,18))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (84...86) = ".."
│ │ ├── operator_loc: (11,14)-(11,16) = ".."
│ │ └── flags: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (89...90))
│ │ @ StatementsNode (location: (12,0)-(12,1))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (89...90))
│ │ └── @ LocalVariableReadNode (location: (12,0)-(12,1))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── for_keyword_loc: (70...73) = "for"
│ ├── in_keyword_loc: (80...82) = "in"
│ ├── for_keyword_loc: (11,0)-(11,3) = "for"
│ ├── in_keyword_loc: (11,10)-(11,12) = "in"
│ ├── do_keyword_loc: ∅
│ └── end_keyword_loc: (91...94) = "end"
├── @ ForNode (location: (96...119))
│ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ ForNode (location: (15,0)-(17,3))
│ ├── index:
│ │ @ LocalVariableTargetNode (location: (100...101))
│ │ @ LocalVariableTargetNode (location: (15,4)-(15,5))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── collection:
│ │ @ RangeNode (location: (105...110))
│ │ @ RangeNode (location: (15,9)-(15,14))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (105...106))
│ │ │ @ IntegerNode (location: (15,9)-(15,10))
│ │ │ └── flags: decimal
│ │ ├── right:
│ │ │ @ IntegerNode (location: (108...110))
│ │ │ @ IntegerNode (location: (15,12)-(15,14))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (106...108) = ".."
│ │ ├── operator_loc: (15,10)-(15,12) = ".."
│ │ └── flags: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (114...115))
│ │ @ StatementsNode (location: (16,0)-(16,1))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (114...115))
│ │ └── @ LocalVariableReadNode (location: (16,0)-(16,1))
│ │ ├── name: :i
│ │ └── depth: 0
│ ├── for_keyword_loc: (96...99) = "for"
│ ├── in_keyword_loc: (102...104) = "in"
│ ├── do_keyword_loc: (111...113) = "do"
│ └── end_keyword_loc: (116...119) = "end"
└── @ ForNode (location: (121...143))
│ ├── for_keyword_loc: (15,0)-(15,3) = "for"
│ ├── in_keyword_loc: (15,6)-(15,8) = "in"
│ ├── do_keyword_loc: (15,15)-(15,17) = "do"
│ └── end_keyword_loc: (17,0)-(17,3) = "end"
└── @ ForNode (location: (19,0)-(19,22))
├── index:
│ @ LocalVariableTargetNode (location: (125...126))
│ @ LocalVariableTargetNode (location: (19,4)-(19,5))
│ ├── name: :i
│ └── depth: 0
├── collection:
│ @ RangeNode (location: (130...135))
│ @ RangeNode (location: (19,9)-(19,14))
│ ├── left:
│ │ @ IntegerNode (location: (130...131))
│ │ @ IntegerNode (location: (19,9)-(19,10))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (133...135))
│ │ @ IntegerNode (location: (19,12)-(19,14))
│ │ └── flags: decimal
│ ├── operator_loc: (131...133) = ".."
│ ├── operator_loc: (19,10)-(19,12) = ".."
│ └── flags: ∅
├── statements:
│ @ StatementsNode (location: (137...138))
│ @ StatementsNode (location: (19,16)-(19,17))
│ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (137...138))
│ └── @ LocalVariableReadNode (location: (19,16)-(19,17))
│ ├── name: :i
│ └── depth: 0
├── for_keyword_loc: (121...124) = "for"
├── in_keyword_loc: (127...129) = "in"
├── for_keyword_loc: (19,0)-(19,3) = "for"
├── in_keyword_loc: (19,6)-(19,8) = "in"
├── 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: []
└── statements:
@ StatementsNode (location: (0...349))
@ StatementsNode (location: (1,0)-(93,4))
└── body: (length: 47)
├── @ GlobalVariableReadNode (location: (0...16))
├── @ GlobalVariableReadNode (location: (1,0)-(1,16))
│ └── name: :$global_variable
├── @ GlobalVariableReadNode (location: (18...20))
├── @ GlobalVariableReadNode (location: (3,0)-(3,2))
│ └── name: :$_
├── @ GlobalVariableReadNode (location: (22...25))
├── @ GlobalVariableReadNode (location: (5,0)-(5,3))
│ └── name: :$-w
├── @ GlobalVariableReadNode (location: (27...37))
├── @ GlobalVariableReadNode (location: (7,0)-(7,10))
│ └── name: :$LOAD_PATH
├── @ GlobalVariableReadNode (location: (39...45))
├── @ GlobalVariableReadNode (location: (9,0)-(9,6))
│ └── name: :$stdin
├── @ GlobalVariableReadNode (location: (47...54))
├── @ GlobalVariableReadNode (location: (11,0)-(11,7))
│ └── name: :$stdout
├── @ GlobalVariableReadNode (location: (56...63))
├── @ GlobalVariableReadNode (location: (13,0)-(13,7))
│ └── name: :$stderr
├── @ GlobalVariableReadNode (location: (65...67))
├── @ GlobalVariableReadNode (location: (15,0)-(15,2))
│ └── name: :$!
├── @ GlobalVariableReadNode (location: (69...71))
├── @ GlobalVariableReadNode (location: (17,0)-(17,2))
│ └── name: :$?
├── @ GlobalVariableReadNode (location: (73...75))
├── @ GlobalVariableReadNode (location: (19,0)-(19,2))
│ └── name: :$~
├── @ BackReferenceReadNode (location: (77...79))
├── @ BackReferenceReadNode (location: (81...83))
├── @ BackReferenceReadNode (location: (85...87))
├── @ BackReferenceReadNode (location: (89...91))
├── @ GlobalVariableReadNode (location: (93...95))
├── @ BackReferenceReadNode (location: (21,0)-(21,2))
├── @ BackReferenceReadNode (location: (23,0)-(23,2))
├── @ BackReferenceReadNode (location: (25,0)-(25,2))
├── @ BackReferenceReadNode (location: (27,0)-(27,2))
├── @ GlobalVariableReadNode (location: (29,0)-(29,2))
│ └── name: :$:
├── @ GlobalVariableReadNode (location: (97...99))
├── @ GlobalVariableReadNode (location: (31,0)-(31,2))
│ └── name: :$;
├── @ GlobalVariableReadNode (location: (101...103))
├── @ GlobalVariableReadNode (location: (33,0)-(33,2))
│ └── name: :$,
├── @ GlobalVariableReadNode (location: (105...111))
├── @ GlobalVariableReadNode (location: (35,0)-(35,6))
│ └── name: :$DEBUG
├── @ GlobalVariableReadNode (location: (113...122))
├── @ GlobalVariableReadNode (location: (37,0)-(37,9))
│ └── name: :$FILENAME
├── @ GlobalVariableReadNode (location: (124...126))
├── @ GlobalVariableReadNode (location: (39,0)-(39,2))
│ └── name: :$0
├── @ GlobalVariableReadNode (location: (128...131))
├── @ GlobalVariableReadNode (location: (41,0)-(41,3))
│ └── name: :$-0
├── @ GlobalVariableReadNode (location: (133...149))
├── @ GlobalVariableReadNode (location: (43,0)-(43,16))
│ └── name: :$LOADED_FEATURES
├── @ GlobalVariableReadNode (location: (151...159))
├── @ GlobalVariableReadNode (location: (45,0)-(45,8))
│ └── name: :$VERBOSE
├── @ GlobalVariableReadNode (location: (161...164))
├── @ GlobalVariableReadNode (location: (47,0)-(47,3))
│ └── name: :$-K
├── @ SymbolNode (location: (166...183))
│ ├── opening_loc: (166...167) = ":"
│ ├── value_loc: (167...183) = "$global_variable"
├── @ SymbolNode (location: (49,0)-(49,17))
│ ├── opening_loc: (49,0)-(49,1) = ":"
│ ├── value_loc: (49,1)-(49,17) = "$global_variable"
│ ├── closing_loc: ∅
│ └── unescaped: "$global_variable"
├── @ SymbolNode (location: (185...188))
│ ├── opening_loc: (185...186) = ":"
│ ├── value_loc: (186...188) = "$_"
├── @ SymbolNode (location: (51,0)-(51,3))
│ ├── opening_loc: (51,0)-(51,1) = ":"
│ ├── value_loc: (51,1)-(51,3) = "$_"
│ ├── closing_loc: ∅
│ └── unescaped: "$_"
├── @ SymbolNode (location: (190...194))
│ ├── opening_loc: (190...191) = ":"
│ ├── value_loc: (191...194) = "$-w"
├── @ SymbolNode (location: (53,0)-(53,4))
│ ├── opening_loc: (53,0)-(53,1) = ":"
│ ├── value_loc: (53,1)-(53,4) = "$-w"
│ ├── closing_loc: ∅
│ └── unescaped: "$-w"
├── @ SymbolNode (location: (196...207))
│ ├── opening_loc: (196...197) = ":"
│ ├── value_loc: (197...207) = "$LOAD_PATH"
├── @ SymbolNode (location: (55,0)-(55,11))
│ ├── opening_loc: (55,0)-(55,1) = ":"
│ ├── value_loc: (55,1)-(55,11) = "$LOAD_PATH"
│ ├── closing_loc: ∅
│ └── unescaped: "$LOAD_PATH"
├── @ SymbolNode (location: (209...216))
│ ├── opening_loc: (209...210) = ":"
│ ├── value_loc: (210...216) = "$stdin"
├── @ SymbolNode (location: (57,0)-(57,7))
│ ├── opening_loc: (57,0)-(57,1) = ":"
│ ├── value_loc: (57,1)-(57,7) = "$stdin"
│ ├── closing_loc: ∅
│ └── unescaped: "$stdin"
├── @ SymbolNode (location: (218...226))
│ ├── opening_loc: (218...219) = ":"
│ ├── value_loc: (219...226) = "$stdout"
├── @ SymbolNode (location: (59,0)-(59,8))
│ ├── opening_loc: (59,0)-(59,1) = ":"
│ ├── value_loc: (59,1)-(59,8) = "$stdout"
│ ├── closing_loc: ∅
│ └── unescaped: "$stdout"
├── @ SymbolNode (location: (228...236))
│ ├── opening_loc: (228...229) = ":"
│ ├── value_loc: (229...236) = "$stderr"
├── @ SymbolNode (location: (61,0)-(61,8))
│ ├── opening_loc: (61,0)-(61,1) = ":"
│ ├── value_loc: (61,1)-(61,8) = "$stderr"
│ ├── closing_loc: ∅
│ └── unescaped: "$stderr"
├── @ SymbolNode (location: (238...241))
│ ├── opening_loc: (238...239) = ":"
│ ├── value_loc: (239...241) = "$!"
├── @ SymbolNode (location: (63,0)-(63,3))
│ ├── opening_loc: (63,0)-(63,1) = ":"
│ ├── value_loc: (63,1)-(63,3) = "$!"
│ ├── closing_loc: ∅
│ └── unescaped: "$!"
├── @ SymbolNode (location: (243...246))
│ ├── opening_loc: (243...244) = ":"
│ ├── value_loc: (244...246) = "$?"
├── @ SymbolNode (location: (65,0)-(65,3))
│ ├── opening_loc: (65,0)-(65,1) = ":"
│ ├── value_loc: (65,1)-(65,3) = "$?"
│ ├── closing_loc: ∅
│ └── unescaped: "$?"
├── @ SymbolNode (location: (248...251))
│ ├── opening_loc: (248...249) = ":"
│ ├── value_loc: (249...251) = "$~"
├── @ SymbolNode (location: (67,0)-(67,3))
│ ├── opening_loc: (67,0)-(67,1) = ":"
│ ├── value_loc: (67,1)-(67,3) = "$~"
│ ├── closing_loc: ∅
│ └── unescaped: "$~"
├── @ SymbolNode (location: (253...256))
│ ├── opening_loc: (253...254) = ":"
│ ├── value_loc: (254...256) = "$&"
├── @ SymbolNode (location: (69,0)-(69,3))
│ ├── opening_loc: (69,0)-(69,1) = ":"
│ ├── value_loc: (69,1)-(69,3) = "$&"
│ ├── closing_loc: ∅
│ └── unescaped: "$&"
├── @ SymbolNode (location: (258...261))
│ ├── opening_loc: (258...259) = ":"
│ ├── value_loc: (259...261) = "$`"
├── @ SymbolNode (location: (71,0)-(71,3))
│ ├── opening_loc: (71,0)-(71,1) = ":"
│ ├── value_loc: (71,1)-(71,3) = "$`"
│ ├── closing_loc: ∅
│ └── unescaped: "$`"
├── @ SymbolNode (location: (263...266))
│ ├── opening_loc: (263...264) = ":"
│ ├── value_loc: (264...266) = "$'"
├── @ SymbolNode (location: (73,0)-(73,3))
│ ├── opening_loc: (73,0)-(73,1) = ":"
│ ├── value_loc: (73,1)-(73,3) = "$'"
│ ├── closing_loc: ∅
│ └── unescaped: "$'"
├── @ SymbolNode (location: (268...271))
│ ├── opening_loc: (268...269) = ":"
│ ├── value_loc: (269...271) = "$+"
├── @ SymbolNode (location: (75,0)-(75,3))
│ ├── opening_loc: (75,0)-(75,1) = ":"
│ ├── value_loc: (75,1)-(75,3) = "$+"
│ ├── closing_loc: ∅
│ └── unescaped: "$+"
├── @ SymbolNode (location: (273...276))
│ ├── opening_loc: (273...274) = ":"
│ ├── value_loc: (274...276) = "$:"
├── @ SymbolNode (location: (77,0)-(77,3))
│ ├── opening_loc: (77,0)-(77,1) = ":"
│ ├── value_loc: (77,1)-(77,3) = "$:"
│ ├── closing_loc: ∅
│ └── unescaped: "$:"
├── @ SymbolNode (location: (278...281))
│ ├── opening_loc: (278...279) = ":"
│ ├── value_loc: (279...281) = "$;"
├── @ SymbolNode (location: (79,0)-(79,3))
│ ├── opening_loc: (79,0)-(79,1) = ":"
│ ├── value_loc: (79,1)-(79,3) = "$;"
│ ├── closing_loc: ∅
│ └── unescaped: "$;"
├── @ SymbolNode (location: (283...290))
│ ├── opening_loc: (283...284) = ":"
│ ├── value_loc: (284...290) = "$DEBUG"
├── @ SymbolNode (location: (81,0)-(81,7))
│ ├── opening_loc: (81,0)-(81,1) = ":"
│ ├── value_loc: (81,1)-(81,7) = "$DEBUG"
│ ├── closing_loc: ∅
│ └── unescaped: "$DEBUG"
├── @ SymbolNode (location: (292...302))
│ ├── opening_loc: (292...293) = ":"
│ ├── value_loc: (293...302) = "$FILENAME"
├── @ SymbolNode (location: (83,0)-(83,10))
│ ├── opening_loc: (83,0)-(83,1) = ":"
│ ├── value_loc: (83,1)-(83,10) = "$FILENAME"
│ ├── closing_loc: ∅
│ └── unescaped: "$FILENAME"
├── @ SymbolNode (location: (304...307))
│ ├── opening_loc: (304...305) = ":"
│ ├── value_loc: (305...307) = "$0"
├── @ SymbolNode (location: (85,0)-(85,3))
│ ├── opening_loc: (85,0)-(85,1) = ":"
│ ├── value_loc: (85,1)-(85,3) = "$0"
│ ├── closing_loc: ∅
│ └── unescaped: "$0"
├── @ SymbolNode (location: (309...313))
│ ├── opening_loc: (309...310) = ":"
│ ├── value_loc: (310...313) = "$-0"
├── @ SymbolNode (location: (87,0)-(87,4))
│ ├── opening_loc: (87,0)-(87,1) = ":"
│ ├── value_loc: (87,1)-(87,4) = "$-0"
│ ├── closing_loc: ∅
│ └── unescaped: "$-0"
├── @ SymbolNode (location: (315...332))
│ ├── opening_loc: (315...316) = ":"
│ ├── value_loc: (316...332) = "$LOADED_FEATURES"
├── @ SymbolNode (location: (89,0)-(89,17))
│ ├── opening_loc: (89,0)-(89,1) = ":"
│ ├── value_loc: (89,1)-(89,17) = "$LOADED_FEATURES"
│ ├── closing_loc: ∅
│ └── unescaped: "$LOADED_FEATURES"
├── @ SymbolNode (location: (334...343))
│ ├── opening_loc: (334...335) = ":"
│ ├── value_loc: (335...343) = "$VERBOSE"
├── @ SymbolNode (location: (91,0)-(91,9))
│ ├── opening_loc: (91,0)-(91,1) = ":"
│ ├── value_loc: (91,1)-(91,9) = "$VERBOSE"
│ ├── closing_loc: ∅
│ └── unescaped: "$VERBOSE"
└── @ SymbolNode (location: (345...349))
├── opening_loc: (345...346) = ":"
├── value_loc: (346...349) = "$-K"
└── @ SymbolNode (location: (93,0)-(93,4))
├── opening_loc: (93,0)-(93,1) = ":"
├── value_loc: (93,1)-(93,4) = "$-K"
├── closing_loc: ∅
└── 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]
└── statements:
@ StatementsNode (location: (0...167))
@ StatementsNode (location: (1,0)-(26,3))
└── body: (length: 9)
├── @ HashNode (location: (0...2))
│ ├── opening_loc: (0...1) = "{"
├── @ HashNode (location: (1,0)-(1,2))
│ ├── opening_loc: (1,0)-(1,1) = "{"
│ ├── elements: (length: 0)
│ └── closing_loc: (1...2) = "}"
├── @ HashNode (location: (4...7))
│ ├── opening_loc: (4...5) = "{"
│ └── closing_loc: (1,1)-(1,2) = "}"
├── @ HashNode (location: (3,0)-(4,1))
│ ├── opening_loc: (3,0)-(3,1) = "{"
│ ├── elements: (length: 0)
│ └── closing_loc: (6...7) = "}"
├── @ HashNode (location: (9...27))
│ ├── opening_loc: (9...10) = "{"
│ └── closing_loc: (4,0)-(4,1) = "}"
├── @ HashNode (location: (6,0)-(6,18))
│ ├── opening_loc: (6,0)-(6,1) = "{"
│ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (11...17))
│ │ ├── @ AssocNode (location: (6,2)-(6,8))
│ │ │ ├── key:
│ │ │ │ @ CallNode (location: (11...12))
│ │ │ │ @ CallNode (location: (6,2)-(6,3))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (11...12) = "a"
│ │ │ │ ├── message_loc: (6,2)-(6,3) = "a"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -27,23 +27,23 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "a"
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (16...17))
│ │ │ │ @ CallNode (location: (6,7)-(6,8))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (16...17) = "b"
│ │ │ │ ├── message_loc: (6,7)-(6,8) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── operator_loc: (13...15) = "=>"
│ │ └── @ AssocNode (location: (19...25))
│ │ │ └── operator_loc: (6,4)-(6,6) = "=>"
│ │ └── @ AssocNode (location: (6,10)-(6,16))
│ │ ├── key:
│ │ │ @ CallNode (location: (19...20))
│ │ │ @ CallNode (location: (6,10)-(6,11))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (19...20) = "c"
│ │ │ ├── message_loc: (6,10)-(6,11) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -51,27 +51,27 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "c"
│ │ ├── value:
│ │ │ @ CallNode (location: (24...25))
│ │ │ @ CallNode (location: (6,15)-(6,16))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (24...25) = "d"
│ │ │ ├── message_loc: (6,15)-(6,16) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ └── operator_loc: (21...23) = "=>"
│ └── closing_loc: (26...27) = "}"
├── @ HashNode (location: (29...44))
│ ├── opening_loc: (29...30) = "{"
│ │ └── operator_loc: (6,12)-(6,14) = "=>"
│ └── closing_loc: (6,17)-(6,18) = "}"
├── @ HashNode (location: (8,0)-(8,15))
│ ├── opening_loc: (8,0)-(8,1) = "{"
│ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (31...37))
│ │ ├── @ AssocNode (location: (8,2)-(8,8))
│ │ │ ├── key:
│ │ │ │ @ CallNode (location: (31...32))
│ │ │ │ @ CallNode (location: (8,2)-(8,3))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (31...32) = "a"
│ │ │ │ ├── message_loc: (8,2)-(8,3) = "a"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -79,46 +79,46 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "a"
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (36...37))
│ │ │ │ @ CallNode (location: (8,7)-(8,8))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (36...37) = "b"
│ │ │ │ ├── message_loc: (8,7)-(8,8) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── operator_loc: (33...35) = "=>"
│ │ └── @ AssocSplatNode (location: (39...42))
│ │ │ └── operator_loc: (8,4)-(8,6) = "=>"
│ │ └── @ AssocSplatNode (location: (8,10)-(8,13))
│ │ ├── value:
│ │ │ @ CallNode (location: (41...42))
│ │ │ @ CallNode (location: (8,12)-(8,13))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (41...42) = "c"
│ │ │ ├── message_loc: (8,12)-(8,13) = "c"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "c"
│ │ └── operator_loc: (39...41) = "**"
│ └── closing_loc: (43...44) = "}"
├── @ HashNode (location: (46...79))
│ ├── opening_loc: (46...47) = "{"
│ │ └── operator_loc: (8,10)-(8,12) = "**"
│ └── closing_loc: (8,14)-(8,15) = "}"
├── @ HashNode (location: (10,0)-(16,5))
│ ├── opening_loc: (10,0)-(10,1) = "{"
│ ├── elements: (length: 2)
│ │ ├── @ AssocNode (location: (54...58))
│ │ ├── @ AssocNode (location: (11,6)-(11,10))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (54...56))
│ │ │ │ @ SymbolNode (location: (11,6)-(11,8))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (54...55) = "a"
│ │ │ │ ├── closing_loc: (55...56) = ":"
│ │ │ │ ├── value_loc: (11,6)-(11,7) = "a"
│ │ │ │ ├── closing_loc: (11,7)-(11,8) = ":"
│ │ │ │ └── unescaped: "a"
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (57...58))
│ │ │ │ @ CallNode (location: (11,9)-(11,10))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (57...58) = "b"
│ │ │ │ ├── message_loc: (11,9)-(11,10) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -126,18 +126,18 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── operator_loc: ∅
│ │ └── @ AssocNode (location: (66...70))
│ │ └── @ AssocNode (location: (12,6)-(12,10))
│ │ ├── key:
│ │ │ @ SymbolNode (location: (66...68))
│ │ │ @ SymbolNode (location: (12,6)-(12,8))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (66...67) = "c"
│ │ │ ├── closing_loc: (67...68) = ":"
│ │ │ ├── value_loc: (12,6)-(12,7) = "c"
│ │ │ ├── closing_loc: (12,7)-(12,8) = ":"
│ │ │ └── unescaped: "c"
│ │ ├── value:
│ │ │ @ CallNode (location: (69...70))
│ │ │ @ CallNode (location: (12,9)-(12,10))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (69...70) = "d"
│ │ │ ├── message_loc: (12,9)-(12,10) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -145,22 +145,22 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ └── operator_loc: ∅
│ └── closing_loc: (78...79) = "}"
├── @ HashNode (location: (81...106))
│ ├── opening_loc: (81...82) = "{"
│ └── closing_loc: (16,4)-(16,5) = "}"
├── @ HashNode (location: (18,0)-(18,25))
│ ├── opening_loc: (18,0)-(18,1) = "{"
│ ├── elements: (length: 4)
│ │ ├── @ AssocNode (location: (83...87))
│ │ ├── @ AssocNode (location: (18,2)-(18,6))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (83...85))
│ │ │ │ @ SymbolNode (location: (18,2)-(18,4))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (83...84) = "a"
│ │ │ │ ├── closing_loc: (84...85) = ":"
│ │ │ │ ├── value_loc: (18,2)-(18,3) = "a"
│ │ │ │ ├── closing_loc: (18,3)-(18,4) = ":"
│ │ │ │ └── unescaped: "a"
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (86...87))
│ │ │ │ @ CallNode (location: (18,5)-(18,6))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (86...87) = "b"
│ │ │ │ ├── message_loc: (18,5)-(18,6) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -168,18 +168,18 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "b"
│ │ │ └── operator_loc: ∅
│ │ ├── @ AssocNode (location: (89...93))
│ │ ├── @ AssocNode (location: (18,8)-(18,12))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (89...91))
│ │ │ │ @ SymbolNode (location: (18,8)-(18,10))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (89...90) = "c"
│ │ │ │ ├── closing_loc: (90...91) = ":"
│ │ │ │ ├── value_loc: (18,8)-(18,9) = "c"
│ │ │ │ ├── closing_loc: (18,9)-(18,10) = ":"
│ │ │ │ └── unescaped: "c"
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (92...93))
│ │ │ │ @ CallNode (location: (18,11)-(18,12))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (92...93) = "d"
│ │ │ │ ├── message_loc: (18,11)-(18,12) = "d"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -187,31 +187,31 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "d"
│ │ │ └── operator_loc: ∅
│ │ ├── @ AssocSplatNode (location: (95...98))
│ │ ├── @ AssocSplatNode (location: (18,14)-(18,17))
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (97...98))
│ │ │ │ @ CallNode (location: (18,16)-(18,17))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (97...98) = "e"
│ │ │ │ ├── message_loc: (18,16)-(18,17) = "e"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "e"
│ │ │ └── operator_loc: (95...97) = "**"
│ │ └── @ AssocNode (location: (100...104))
│ │ │ └── operator_loc: (18,14)-(18,16) = "**"
│ │ └── @ AssocNode (location: (18,19)-(18,23))
│ │ ├── key:
│ │ │ @ SymbolNode (location: (100...102))
│ │ │ @ SymbolNode (location: (18,19)-(18,21))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (100...101) = "f"
│ │ │ ├── closing_loc: (101...102) = ":"
│ │ │ ├── value_loc: (18,19)-(18,20) = "f"
│ │ │ ├── closing_loc: (18,20)-(18,21) = ":"
│ │ │ └── unescaped: "f"
│ │ ├── value:
│ │ │ @ CallNode (location: (103...104))
│ │ │ @ CallNode (location: (18,22)-(18,23))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (103...104) = "g"
│ │ │ ├── message_loc: (18,22)-(18,23) = "g"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -219,24 +219,24 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "g"
│ │ └── operator_loc: ∅
│ └── closing_loc: (105...106) = "}"
├── @ HashNode (location: (108...120))
│ ├── opening_loc: (108...109) = "{"
│ └── closing_loc: (18,24)-(18,25) = "}"
├── @ HashNode (location: (20,0)-(20,12))
│ ├── opening_loc: (20,0)-(20,1) = "{"
│ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (110...118))
│ │ └── @ AssocNode (location: (20,2)-(20,10))
│ │ ├── key:
│ │ │ @ SymbolNode (location: (110...114))
│ │ │ ├── opening_loc: (110...111) = "\""
│ │ │ ├── value_loc: (111...112) = "a"
│ │ │ ├── closing_loc: (112...114) = "\":"
│ │ │ @ SymbolNode (location: (20,2)-(20,6))
│ │ │ ├── opening_loc: (20,2)-(20,3) = "\""
│ │ │ ├── value_loc: (20,3)-(20,4) = "a"
│ │ │ ├── closing_loc: (20,4)-(20,6) = "\":"
│ │ │ └── unescaped: "a"
│ │ ├── value:
│ │ │ @ CallNode (location: (115...118))
│ │ │ @ CallNode (location: (20,7)-(20,10))
│ │ │ ├── receiver:
│ │ │ │ @ CallNode (location: (116...118))
│ │ │ │ @ CallNode (location: (20,8)-(20,10))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (116...118) = "b?"
│ │ │ │ ├── message_loc: (20,8)-(20,10) = "b?"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -244,7 +244,7 @@
│ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "b?"
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (115...116) = "!"
│ │ │ ├── message_loc: (20,7)-(20,8) = "!"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -252,82 +252,82 @@
│ │ │ ├── flags: ∅
│ │ │ └── name: "!"
│ │ └── operator_loc: ∅
│ └── closing_loc: (119...120) = "}"
├── @ LocalVariableWriteNode (location: (122...127))
│ └── closing_loc: (20,11)-(20,12) = "}"
├── @ LocalVariableWriteNode (location: (22,0)-(22,5))
│ ├── name: :a
│ ├── depth: 0
│ ├── name_loc: (122...123) = "a"
│ ├── name_loc: (22,0)-(22,1) = "a"
│ ├── value:
│ │ @ IntegerNode (location: (126...127))
│ │ @ IntegerNode (location: (22,4)-(22,5))
│ │ └── flags: decimal
│ └── operator_loc: (124...125) = "="
└── @ CallNode (location: (128...167))
│ └── operator_loc: (22,2)-(22,3) = "="
└── @ CallNode (location: (23,0)-(26,3))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (128...131) = "tap"
├── message_loc: (23,0)-(23,3) = "tap"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (132...167))
│ @ BlockNode (location: (23,4)-(26,3))
│ ├── locals: [:b]
│ ├── parameters: ∅
│ ├── body:
│ │ @ StatementsNode (location: (137...163))
│ │ @ StatementsNode (location: (24,2)-(25,20))
│ │ └── body: (length: 2)
│ │ ├── @ LocalVariableWriteNode (location: (137...142))
│ │ ├── @ LocalVariableWriteNode (location: (24,2)-(24,7))
│ │ │ ├── name: :b
│ │ │ ├── depth: 0
│ │ │ ├── name_loc: (137...138) = "b"
│ │ │ ├── name_loc: (24,2)-(24,3) = "b"
│ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (141...142))
│ │ │ │ @ IntegerNode (location: (24,6)-(24,7))
│ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (139...140) = "="
│ │ └── @ HashNode (location: (145...163))
│ │ ├── opening_loc: (145...146) = "{"
│ │ │ └── operator_loc: (24,4)-(24,5) = "="
│ │ └── @ HashNode (location: (25,2)-(25,20))
│ │ ├── opening_loc: (25,2)-(25,3) = "{"
│ │ ├── elements: (length: 4)
│ │ │ ├── @ AssocNode (location: (147...149))
│ │ │ ├── @ AssocNode (location: (25,4)-(25,6))
│ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (147...149))
│ │ │ │ │ @ SymbolNode (location: (25,4)-(25,6))
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (147...148) = "a"
│ │ │ │ │ ├── closing_loc: (148...149) = ":"
│ │ │ │ │ ├── value_loc: (25,4)-(25,5) = "a"
│ │ │ │ │ ├── closing_loc: (25,5)-(25,6) = ":"
│ │ │ │ │ └── unescaped: "a"
│ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (147...149))
│ │ │ │ │ @ ImplicitNode (location: (25,4)-(25,6))
│ │ │ │ │ └── value:
│ │ │ │ │ @ LocalVariableReadNode (location: (147...149))
│ │ │ │ │ @ LocalVariableReadNode (location: (25,4)-(25,6))
│ │ │ │ │ ├── name: :a
│ │ │ │ │ └── depth: 1
│ │ │ │ └── operator_loc: ∅
│ │ │ ├── @ AssocNode (location: (151...153))
│ │ │ ├── @ AssocNode (location: (25,8)-(25,10))
│ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (151...153))
│ │ │ │ │ @ SymbolNode (location: (25,8)-(25,10))
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (151...152) = "b"
│ │ │ │ │ ├── closing_loc: (152...153) = ":"
│ │ │ │ │ ├── value_loc: (25,8)-(25,9) = "b"
│ │ │ │ │ ├── closing_loc: (25,9)-(25,10) = ":"
│ │ │ │ │ └── unescaped: "b"
│ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (151...153))
│ │ │ │ │ @ ImplicitNode (location: (25,8)-(25,10))
│ │ │ │ │ └── value:
│ │ │ │ │ @ LocalVariableReadNode (location: (151...153))
│ │ │ │ │ @ LocalVariableReadNode (location: (25,8)-(25,10))
│ │ │ │ │ ├── name: :b
│ │ │ │ │ └── depth: 0
│ │ │ │ └── operator_loc: ∅
│ │ │ ├── @ AssocNode (location: (155...157))
│ │ │ ├── @ AssocNode (location: (25,12)-(25,14))
│ │ │ │ ├── key:
│ │ │ │ │ @ SymbolNode (location: (155...157))
│ │ │ │ │ @ SymbolNode (location: (25,12)-(25,14))
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── value_loc: (155...156) = "c"
│ │ │ │ │ ├── closing_loc: (156...157) = ":"
│ │ │ │ │ ├── value_loc: (25,12)-(25,13) = "c"
│ │ │ │ │ ├── closing_loc: (25,13)-(25,14) = ":"
│ │ │ │ │ └── unescaped: "c"
│ │ │ │ ├── value:
│ │ │ │ │ @ ImplicitNode (location: (155...157))
│ │ │ │ │ @ ImplicitNode (location: (25,12)-(25,14))
│ │ │ │ │ └── value:
│ │ │ │ │ @ CallNode (location: (155...157))
│ │ │ │ │ @ CallNode (location: (25,12)-(25,14))
│ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (155...156) = "c"
│ │ │ │ │ ├── message_loc: (25,12)-(25,13) = "c"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
@ -335,21 +335,21 @@
│ │ │ │ │ ├── flags: ∅
│ │ │ │ │ └── name: "c"
│ │ │ │ └── operator_loc: ∅
│ │ │ └── @ AssocNode (location: (159...161))
│ │ │ └── @ AssocNode (location: (25,16)-(25,18))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (159...161))
│ │ │ │ @ SymbolNode (location: (25,16)-(25,18))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (159...160) = "D"
│ │ │ │ ├── closing_loc: (160...161) = ":"
│ │ │ │ ├── value_loc: (25,16)-(25,17) = "D"
│ │ │ │ ├── closing_loc: (25,17)-(25,18) = ":"
│ │ │ │ └── unescaped: "D"
│ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (159...161))
│ │ │ │ @ ImplicitNode (location: (25,16)-(25,18))
│ │ │ │ └── value:
│ │ │ │ @ ConstantReadNode (location: (159...161))
│ │ │ │ @ ConstantReadNode (location: (25,16)-(25,18))
│ │ │ │ └── name: :D
│ │ │ └── operator_loc: ∅
│ │ └── closing_loc: (162...163) = "}"
│ ├── opening_loc: (132...134) = "do"
│ └── closing_loc: (164...167) = "end"
│ │ └── closing_loc: (25,19)-(25,20) = "}"
│ ├── opening_loc: (23,4)-(23,6) = "do"
│ └── closing_loc: (26,0)-(26,3) = "end"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...62))
@ StatementsNode (location: (1,0)-(5,25))
└── body: (length: 2)
├── @ CallNode (location: (0...25))
├── @ CallNode (location: (1,0)-(1,25))
│ ├── receiver:
│ │ @ StringNode (location: (0...9))
│ │ @ StringNode (location: (1,0)-(1,9))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (0...9) = "<<-TARGET"
│ │ ├── content_loc: (27...27) = ""
│ │ ├── closing_loc: (27...34) = "TARGET\n"
│ │ ├── opening_loc: (1,0)-(1,9) = "<<-TARGET"
│ │ ├── content_loc: (2,0)-(1,0) = ""
│ │ ├── closing_loc: (2,0)-(2,0) = "TARGET\n"
│ │ └── unescaped: ""
│ ├── call_operator_loc: (9...10) = "."
│ ├── message_loc: (10...14) = "gsub"
│ ├── call_operator_loc: (1,9)-(1,10) = "."
│ ├── message_loc: (1,10)-(1,14) = "gsub"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (15...25))
│ │ @ ArgumentsNode (location: (1,15)-(1,25))
│ │ └── arguments: (length: 2)
│ │ ├── @ RegularExpressionNode (location: (15...21))
│ │ │ ├── opening_loc: (15...16) = "/"
│ │ │ ├── content_loc: (16...20) = "^\\s{"
│ │ │ ├── closing_loc: (20...21) = "/"
│ │ ├── @ RegularExpressionNode (location: (1,15)-(1,21))
│ │ │ ├── opening_loc: (1,15)-(1,16) = "/"
│ │ │ ├── content_loc: (1,16)-(1,20) = "^\\s{"
│ │ │ ├── closing_loc: (1,20)-(1,21) = "/"
│ │ │ ├── unescaped: "^ {"
│ │ │ └── flags: ∅
│ │ └── @ StringNode (location: (23...25))
│ │ └── @ StringNode (location: (1,23)-(1,25))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (23...24) = "'"
│ │ ├── content_loc: (24...24) = ""
│ │ ├── closing_loc: (24...25) = "'"
│ │ ├── opening_loc: (1,23)-(1,24) = "'"
│ │ ├── content_loc: (1,24)-(1,24) = ""
│ │ ├── closing_loc: (1,24)-(1,25) = "'"
│ │ └── unescaped: ""
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "gsub"
└── @ CallNode (location: (37...62))
└── @ CallNode (location: (5,0)-(5,25))
├── receiver:
│ @ StringNode (location: (37...46))
│ @ StringNode (location: (5,0)-(5,9))
│ ├── flags: ∅
│ ├── opening_loc: (37...46) = "<<-TARGET"
│ ├── content_loc: (65...65) = ""
│ ├── closing_loc: (65...73) = "TARGET\r\n"
│ ├── opening_loc: (5,0)-(5,9) = "<<-TARGET"
│ ├── content_loc: (6,0)-(5,0) = ""
│ ├── closing_loc: (6,0)-(6,0) = "TARGET\r\n"
│ └── unescaped: ""
├── call_operator_loc: (46...47) = "."
├── message_loc: (47...51) = "gsub"
├── call_operator_loc: (5,9)-(5,10) = "."
├── message_loc: (5,10)-(5,14) = "gsub"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (52...62))
│ @ ArgumentsNode (location: (5,15)-(5,25))
│ └── arguments: (length: 2)
│ ├── @ RegularExpressionNode (location: (52...58))
│ │ ├── opening_loc: (52...53) = "/"
│ │ ├── content_loc: (53...57) = "^\\s{"
│ │ ├── closing_loc: (57...58) = "/"
│ ├── @ RegularExpressionNode (location: (5,15)-(5,21))
│ │ ├── opening_loc: (5,15)-(5,16) = "/"
│ │ ├── content_loc: (5,16)-(5,20) = "^\\s{"
│ │ ├── closing_loc: (5,20)-(5,21) = "/"
│ │ ├── unescaped: "^ {"
│ │ └── flags: ∅
│ └── @ StringNode (location: (60...62))
│ └── @ StringNode (location: (5,23)-(5,25))
│ ├── flags: ∅
│ ├── opening_loc: (60...61) = "'"
│ ├── content_loc: (61...61) = ""
│ ├── closing_loc: (61...62) = "'"
│ ├── opening_loc: (5,23)-(5,24) = "'"
│ ├── content_loc: (5,24)-(5,24) = ""
│ ├── closing_loc: (5,24)-(5,25) = "'"
│ └── unescaped: ""
├── closing_loc: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...6))
@ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1)
└── @ StringNode (location: (0...6))
└── @ StringNode (location: (1,0)-(1,6))
├── flags: ∅
├── opening_loc: (0...6) = "<<-END"
├── content_loc: (7...7) = ""
├── closing_loc: (7...10) = "END"
├── opening_loc: (1,0)-(1,6) = "<<-END"
├── content_loc: (2,0)-(1,0) = ""
├── closing_loc: (2,0)-(2,3) = "END"
└── 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: []
└── statements:
@ StatementsNode (location: (0...7))
@ StatementsNode (location: (1,0)-(1,7))
└── body: (length: 1)
└── @ InterpolatedStringNode (location: (0...7))
├── opening_loc: (0...7) = "<<~RUBY"
└── @ InterpolatedStringNode (location: (1,0)-(1,7))
├── opening_loc: (1,0)-(1,7) = "<<~RUBY"
├── parts: (length: 3)
│ ├── @ StringNode (location: (8...12))
│ ├── @ StringNode (location: (2,0)-(2,0))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (8...12) = "pre\n"
│ │ ├── content_loc: (2,0)-(2,0) = "pre\n"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "pre\n"
│ ├── @ EmbeddedStatementsNode (location: (12...36))
│ │ ├── opening_loc: (12...14) = "\#{"
│ ├── @ EmbeddedStatementsNode (location: (3,0)-(7,1))
│ │ ├── opening_loc: (3,0)-(3,2) = "\#{"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (15...21))
│ │ │ @ StatementsNode (location: (4,0)-(4,6))
│ │ │ └── body: (length: 1)
│ │ │ └── @ StringNode (location: (15...21))
│ │ │ └── @ StringNode (location: (4,0)-(4,6))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (15...21) = "<<RUBY"
│ │ │ ├── content_loc: (22...30) = " hello\n"
│ │ │ ├── closing_loc: (30...35) = "RUBY\n"
│ │ │ ├── opening_loc: (4,0)-(4,6) = "<<RUBY"
│ │ │ ├── content_loc: (5,0)-(5,0) = " hello\n"
│ │ │ ├── closing_loc: (6,0)-(6,0) = "RUBY\n"
│ │ │ └── unescaped: " hello\n"
│ │ └── closing_loc: (35...36) = "}"
│ └── @ StringNode (location: (36...42))
│ │ └── closing_loc: (7,0)-(7,1) = "}"
│ └── @ StringNode (location: (7,1)-(8,0))
│ ├── flags: ∅
│ ├── opening_loc: ∅
│ ├── content_loc: (36...42) = "\npost\n"
│ ├── content_loc: (7,1)-(8,0) = "\npost\n"
│ ├── closing_loc: ∅
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...23))
@ StatementsNode (location: (1,0)-(4,8))
└── body: (length: 2)
├── @ StringNode (location: (0...7))
├── @ StringNode (location: (1,0)-(1,7))
│ ├── flags: ∅
│ ├── opening_loc: (0...7) = "<<-HERE"
│ ├── content_loc: (9...9) = ""
│ ├── closing_loc: (9...14) = "HERE\n"
│ ├── opening_loc: (1,0)-(1,7) = "<<-HERE"
│ ├── content_loc: (2,0)-(1,0) = ""
│ ├── closing_loc: (2,0)-(2,0) = "HERE\n"
│ └── unescaped: ""
└── @ StringNode (location: (15...23))
└── @ StringNode (location: (4,0)-(4,8))
├── flags: ∅
├── opening_loc: (15...23) = "<<~THERE"
├── content_loc: (25...100) = " 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"
├── opening_loc: (4,0)-(4,8) = "<<~THERE"
├── 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: (14,0)-(14,0) = "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: []
└── statements:
@ StatementsNode (location: (0...6))
@ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1)
└── @ StringNode (location: (0...6))
└── @ StringNode (location: (1,0)-(1,6))
├── flags: ∅
├── opening_loc: (0...6) = "<<-EOE"
├── content_loc: (7...23) = " some\n heredocs\n"
├── closing_loc: (23...26) = "EOE"
├── opening_loc: (1,0)-(1,6) = "<<-EOE"
├── content_loc: (2,0)-(3,0) = " some\n heredocs\n"
├── closing_loc: (4,0)-(4,3) = "EOE"
└── 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: []
└── statements:
@ StatementsNode (location: (0...382))
@ StatementsNode (location: (1,0)-(42,3))
└── body: (length: 13)
├── @ IfNode (location: (0...15))
│ ├── if_keyword_loc: (0...2) = "if"
├── @ IfNode (location: (1,0)-(1,15))
│ ├── if_keyword_loc: (1,0)-(1,2) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (3...7))
│ │ @ TrueNode (location: (1,3)-(1,7))
│ ├── statements:
│ │ @ StatementsNode (location: (9...10))
│ │ @ StatementsNode (location: (1,9)-(1,10))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (9...10))
│ │ └── @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal
│ ├── consequent: ∅
│ └── end_keyword_loc: (12...15) = "end"
├── @ IfNode (location: (17...37))
│ ├── if_keyword_loc: (17...19) = "if"
│ └── end_keyword_loc: (1,12)-(1,15) = "end"
├── @ IfNode (location: (3,0)-(4,12))
│ ├── if_keyword_loc: (3,0)-(3,2) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (20...24))
│ │ @ TrueNode (location: (3,3)-(3,7))
│ ├── statements:
│ │ @ StatementsNode (location: (25...26))
│ │ @ StatementsNode (location: (4,0)-(4,1))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (25...26))
│ │ └── @ IntegerNode (location: (4,0)-(4,1))
│ │ └── flags: decimal
│ ├── consequent:
│ │ @ ElseNode (location: (27...37))
│ │ ├── else_keyword_loc: (27...31) = "else"
│ │ @ ElseNode (location: (4,2)-(4,12))
│ │ ├── else_keyword_loc: (4,2)-(4,6) = "else"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (32...33))
│ │ │ @ StatementsNode (location: (4,7)-(4,8))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (32...33))
│ │ │ └── @ IntegerNode (location: (4,7)-(4,8))
│ │ │ └── flags: decimal
│ │ └── end_keyword_loc: (34...37) = "end"
│ └── end_keyword_loc: (34...37) = "end"
├── @ IfNode (location: (39...112))
│ ├── if_keyword_loc: (39...41) = "if"
│ │ └── end_keyword_loc: (4,9)-(4,12) = "end"
│ └── end_keyword_loc: (4,9)-(4,12) = "end"
├── @ IfNode (location: (6,0)-(6,73))
│ ├── if_keyword_loc: (6,0)-(6,2) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (42...46))
│ │ @ TrueNode (location: (6,3)-(6,7))
│ ├── statements:
│ │ @ StatementsNode (location: (52...56))
│ │ @ StatementsNode (location: (6,13)-(6,17))
│ │ └── body: (length: 1)
│ │ └── @ TrueNode (location: (52...56))
│ │ └── @ TrueNode (location: (6,13)-(6,17))
│ ├── consequent:
│ │ @ IfNode (location: (57...112))
│ │ ├── if_keyword_loc: (57...62) = "elsif"
│ │ @ IfNode (location: (6,18)-(6,73))
│ │ ├── if_keyword_loc: (6,18)-(6,23) = "elsif"
│ │ ├── predicate:
│ │ │ @ FalseNode (location: (63...68))
│ │ │ @ FalseNode (location: (6,24)-(6,29))
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (74...79))
│ │ │ @ StatementsNode (location: (6,35)-(6,40))
│ │ │ └── body: (length: 1)
│ │ │ └── @ FalseNode (location: (74...79))
│ │ │ └── @ FalseNode (location: (6,35)-(6,40))
│ │ ├── consequent:
│ │ │ @ IfNode (location: (80...112))
│ │ │ ├── if_keyword_loc: (80...85) = "elsif"
│ │ │ @ IfNode (location: (6,41)-(6,73))
│ │ │ ├── if_keyword_loc: (6,41)-(6,46) = "elsif"
│ │ │ ├── predicate:
│ │ │ │ @ NilNode (location: (86...89))
│ │ │ │ @ NilNode (location: (6,47)-(6,50))
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (95...98))
│ │ │ │ @ StatementsNode (location: (6,56)-(6,59))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ NilNode (location: (95...98))
│ │ │ │ └── @ NilNode (location: (6,56)-(6,59))
│ │ │ ├── consequent:
│ │ │ │ @ ElseNode (location: (99...112))
│ │ │ │ ├── else_keyword_loc: (99...103) = "else"
│ │ │ │ @ ElseNode (location: (6,60)-(6,73))
│ │ │ │ ├── else_keyword_loc: (6,60)-(6,64) = "else"
│ │ │ │ ├── statements:
│ │ │ │ │ @ StatementsNode (location: (104...108))
│ │ │ │ │ @ StatementsNode (location: (6,65)-(6,69))
│ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ └── @ SelfNode (location: (104...108))
│ │ │ │ └── end_keyword_loc: (109...112) = "end"
│ │ │ └── end_keyword_loc: (109...112) = "end"
│ │ └── end_keyword_loc: (109...112) = "end"
│ └── end_keyword_loc: (109...112) = "end"
├── @ IfNode (location: (114...123))
│ ├── if_keyword_loc: (116...118) = "if"
│ │ │ │ │ └── @ SelfNode (location: (6,65)-(6,69))
│ │ │ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ │ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ │ └── end_keyword_loc: (6,70)-(6,73) = "end"
│ └── end_keyword_loc: (6,70)-(6,73) = "end"
├── @ IfNode (location: (8,0)-(8,9))
│ ├── if_keyword_loc: (8,2)-(8,4) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (119...123))
│ │ @ TrueNode (location: (8,5)-(8,9))
│ ├── statements:
│ │ @ StatementsNode (location: (114...115))
│ │ @ StatementsNode (location: (8,0)-(8,1))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (114...115))
│ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal
│ ├── consequent: ∅
│ └── end_keyword_loc: ∅
├── @ IfNode (location: (125...138))
│ ├── if_keyword_loc: (131...133) = "if"
├── @ IfNode (location: (10,0)-(10,13))
│ ├── if_keyword_loc: (10,6)-(10,8) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (134...138))
│ │ @ TrueNode (location: (10,9)-(10,13))
│ ├── statements:
│ │ @ StatementsNode (location: (125...130))
│ │ @ StatementsNode (location: (10,0)-(10,5))
│ │ └── body: (length: 1)
│ │ └── @ BreakNode (location: (125...130))
│ │ └── @ BreakNode (location: (10,0)-(10,5))
│ │ ├── arguments: ∅
│ │ └── keyword_loc: (125...130) = "break"
│ │ └── keyword_loc: (10,0)-(10,5) = "break"
│ ├── consequent: ∅
│ └── end_keyword_loc: ∅
├── @ IfNode (location: (140...152))
│ ├── if_keyword_loc: (145...147) = "if"
├── @ IfNode (location: (12,0)-(12,12))
│ ├── if_keyword_loc: (12,5)-(12,7) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (148...152))
│ │ @ TrueNode (location: (12,8)-(12,12))
│ ├── statements:
│ │ @ StatementsNode (location: (140...144))
│ │ @ StatementsNode (location: (12,0)-(12,4))
│ │ └── body: (length: 1)
│ │ └── @ NextNode (location: (140...144))
│ │ └── @ NextNode (location: (12,0)-(12,4))
│ │ ├── arguments: ∅
│ │ └── keyword_loc: (140...144) = "next"
│ │ └── keyword_loc: (12,0)-(12,4) = "next"
│ ├── consequent: ∅
│ └── end_keyword_loc: ∅
├── @ IfNode (location: (154...168))
│ ├── if_keyword_loc: (161...163) = "if"
├── @ IfNode (location: (14,0)-(14,14))
│ ├── if_keyword_loc: (14,7)-(14,9) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (164...168))
│ │ @ TrueNode (location: (14,10)-(14,14))
│ ├── statements:
│ │ @ StatementsNode (location: (154...160))
│ │ @ StatementsNode (location: (14,0)-(14,6))
│ │ └── body: (length: 1)
│ │ └── @ ReturnNode (location: (154...160))
│ │ ├── keyword_loc: (154...160) = "return"
│ │ └── @ ReturnNode (location: (14,0)-(14,6))
│ │ ├── keyword_loc: (14,0)-(14,6) = "return"
│ │ └── arguments: ∅
│ ├── consequent: ∅
│ └── end_keyword_loc: ∅
├── @ IfNode (location: (170...200))
│ ├── if_keyword_loc: (170...172) = "if"
├── @ IfNode (location: (16,0)-(16,30))
│ ├── if_keyword_loc: (16,0)-(16,2) = "if"
│ ├── predicate:
│ │ @ CallNode (location: (173...182))
│ │ @ CallNode (location: (16,3)-(16,12))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (173...182) = "exit_loop"
│ │ ├── message_loc: (16,3)-(16,12) = "exit_loop"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -131,24 +131,24 @@
│ │ ├── flags: variable_call
│ │ └── name: "exit_loop"
│ ├── statements:
│ │ @ StatementsNode (location: (188...196))
│ │ @ StatementsNode (location: (16,18)-(16,26))
│ │ └── body: (length: 1)
│ │ └── @ BreakNode (location: (188...196))
│ │ └── @ BreakNode (location: (16,18)-(16,26))
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (194...196))
│ │ │ @ ArgumentsNode (location: (16,24)-(16,26))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (194...196))
│ │ │ └── @ IntegerNode (location: (16,24)-(16,26))
│ │ │ └── flags: decimal
│ │ └── keyword_loc: (188...193) = "break"
│ │ └── keyword_loc: (16,18)-(16,23) = "break"
│ ├── consequent: ∅
│ └── end_keyword_loc: (197...200) = "end"
├── @ IfNode (location: (202...221))
│ ├── if_keyword_loc: (202...204) = "if"
│ └── end_keyword_loc: (16,27)-(16,30) = "end"
├── @ IfNode (location: (18,0)-(20,3))
│ ├── if_keyword_loc: (18,0)-(18,2) = "if"
│ ├── predicate:
│ │ @ CallNode (location: (205...208))
│ │ @ CallNode (location: (18,3)-(18,6))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (205...208) = "foo"
│ │ ├── message_loc: (18,3)-(18,6) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -156,12 +156,12 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── statements:
│ │ @ StatementsNode (location: (214...217))
│ │ @ StatementsNode (location: (19,5)-(19,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (214...217))
│ │ └── @ CallNode (location: (19,5)-(19,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (214...217) = "bar"
│ │ ├── message_loc: (19,5)-(19,8) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -169,14 +169,14 @@
│ │ ├── flags: variable_call
│ │ └── name: "bar"
│ ├── consequent: ∅
│ └── end_keyword_loc: (218...221) = "end"
├── @ IfNode (location: (223...234))
│ ├── if_keyword_loc: (230...232) = "if"
│ └── end_keyword_loc: (20,0)-(20,3) = "end"
├── @ IfNode (location: (22,0)-(22,11))
│ ├── if_keyword_loc: (22,7)-(22,9) = "if"
│ ├── predicate:
│ │ @ CallNode (location: (233...234))
│ │ @ CallNode (location: (22,10)-(22,11))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (233...234) = "c"
│ │ ├── message_loc: (22,10)-(22,11) = "c"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -184,15 +184,15 @@
│ │ ├── flags: variable_call
│ │ └── name: "c"
│ ├── statements:
│ │ @ StatementsNode (location: (223...229))
│ │ @ StatementsNode (location: (22,0)-(22,6))
│ │ └── body: (length: 1)
│ │ └── @ IfNode (location: (223...229))
│ │ ├── if_keyword_loc: (225...227) = "if"
│ │ └── @ IfNode (location: (22,0)-(22,6))
│ │ ├── if_keyword_loc: (22,2)-(22,4) = "if"
│ │ ├── predicate:
│ │ │ @ CallNode (location: (228...229))
│ │ │ @ CallNode (location: (22,5)-(22,6))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (228...229) = "b"
│ │ │ ├── message_loc: (22,5)-(22,6) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -200,12 +200,12 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (223...224))
│ │ │ @ StatementsNode (location: (22,0)-(22,1))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (223...224))
│ │ │ └── @ CallNode (location: (22,0)-(22,1))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (223...224) = "a"
│ │ │ ├── message_loc: (22,0)-(22,1) = "a"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -216,37 +216,37 @@
│ │ └── end_keyword_loc: ∅
│ ├── consequent: ∅
│ └── end_keyword_loc: ∅
├── @ IfNode (location: (236...259))
│ ├── if_keyword_loc: (236...238) = "if"
├── @ IfNode (location: (24,0)-(27,3))
│ ├── if_keyword_loc: (24,0)-(24,2) = "if"
│ ├── predicate:
│ │ @ TrueNode (location: (239...243))
│ │ @ TrueNode (location: (24,3)-(24,7))
│ ├── statements:
│ │ @ StatementsNode (location: (246...250))
│ │ @ StatementsNode (location: (25,2)-(25,6))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (246...250))
│ │ └── @ CallNode (location: (25,2)-(25,6))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (246...247) = "a"
│ │ ├── message_loc: (25,2)-(25,3) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (248...250))
│ │ │ @ ArgumentsNode (location: (25,4)-(25,6))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ KeywordHashNode (location: (248...250))
│ │ │ └── @ KeywordHashNode (location: (25,4)-(25,6))
│ │ │ └── elements: (length: 1)
│ │ │ └── @ AssocNode (location: (248...250))
│ │ │ └── @ AssocNode (location: (25,4)-(25,6))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (248...250))
│ │ │ │ @ SymbolNode (location: (25,4)-(25,6))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (248...249) = "b"
│ │ │ │ ├── closing_loc: (249...250) = ":"
│ │ │ │ ├── value_loc: (25,4)-(25,5) = "b"
│ │ │ │ ├── closing_loc: (25,5)-(25,6) = ":"
│ │ │ │ └── unescaped: "b"
│ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (248...250))
│ │ │ │ @ ImplicitNode (location: (25,4)-(25,6))
│ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (248...250))
│ │ │ │ @ CallNode (location: (25,4)-(25,6))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (248...249) = "b"
│ │ │ │ ├── message_loc: (25,4)-(25,5) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -259,20 +259,20 @@
│ │ ├── flags: ∅
│ │ └── name: "a"
│ ├── consequent:
│ │ @ ElseNode (location: (251...259))
│ │ ├── else_keyword_loc: (251...255) = "else"
│ │ @ ElseNode (location: (26,0)-(27,3))
│ │ ├── else_keyword_loc: (26,0)-(26,4) = "else"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (256...259) = "end"
│ └── end_keyword_loc: (256...259) = "end"
├── @ IfNode (location: (261...293))
│ ├── if_keyword_loc: (261...263) = "if"
│ │ └── end_keyword_loc: (27,0)-(27,3) = "end"
│ └── end_keyword_loc: (27,0)-(27,3) = "end"
├── @ IfNode (location: (29,0)-(31,3))
│ ├── if_keyword_loc: (29,0)-(29,2) = "if"
│ ├── predicate:
│ │ @ MatchPredicateNode (location: (264...273))
│ │ @ MatchPredicateNode (location: (29,3)-(29,12))
│ │ ├── value:
│ │ │ @ CallNode (location: (264...268))
│ │ │ @ CallNode (location: (29,3)-(29,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (264...268) = "type"
│ │ │ ├── message_loc: (29,3)-(29,7) = "type"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -280,20 +280,20 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "type"
│ │ ├── pattern:
│ │ │ @ IntegerNode (location: (272...273))
│ │ │ @ IntegerNode (location: (29,11)-(29,12))
│ │ │ └── flags: decimal
│ │ └── operator_loc: (269...271) = "in"
│ │ └── operator_loc: (29,8)-(29,10) = "in"
│ ├── statements: ∅
│ ├── consequent:
│ │ @ IfNode (location: (274...293))
│ │ ├── if_keyword_loc: (274...279) = "elsif"
│ │ @ IfNode (location: (30,0)-(31,3))
│ │ ├── if_keyword_loc: (30,0)-(30,5) = "elsif"
│ │ ├── predicate:
│ │ │ @ MatchPredicateNode (location: (280...289))
│ │ │ @ MatchPredicateNode (location: (30,6)-(30,15))
│ │ │ ├── value:
│ │ │ │ @ CallNode (location: (280...284))
│ │ │ │ @ CallNode (location: (30,6)-(30,10))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (280...284) = "type"
│ │ │ │ ├── message_loc: (30,6)-(30,10) = "type"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -301,37 +301,37 @@
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "type"
│ │ │ ├── pattern:
│ │ │ │ @ ConstantReadNode (location: (288...289))
│ │ │ │ @ ConstantReadNode (location: (30,14)-(30,15))
│ │ │ │ └── name: :B
│ │ │ └── operator_loc: (285...287) = "in"
│ │ │ └── operator_loc: (30,11)-(30,13) = "in"
│ │ ├── statements: ∅
│ │ ├── consequent: ∅
│ │ └── end_keyword_loc: (290...293) = "end"
│ └── end_keyword_loc: (290...293) = "end"
└── @ IfNode (location: (295...382))
├── if_keyword_loc: (295...297) = "if"
│ │ └── end_keyword_loc: (31,0)-(31,3) = "end"
│ └── end_keyword_loc: (31,0)-(31,3) = "end"
└── @ IfNode (location: (33,0)-(42,3))
├── if_keyword_loc: (33,0)-(33,2) = "if"
├── predicate:
│ @ IntegerNode (location: (298...299))
│ @ IntegerNode (location: (33,3)-(33,4))
│ └── flags: decimal
├── statements:
│ @ StatementsNode (location: (302...321))
│ @ StatementsNode (location: (34,2)-(35,5))
│ └── body: (length: 1)
│ └── @ CallNode (location: (302...321))
│ └── @ CallNode (location: (34,2)-(35,5))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (302...308) = "lambda"
│ ├── message_loc: (34,2)-(34,8) = "lambda"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (309...321))
│ │ @ BlockNode (location: (34,9)-(35,5))
│ │ ├── locals: [:_]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (312...315))
│ │ │ @ BlockParametersNode (location: (34,12)-(34,15))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (313...314))
│ │ │ │ @ ParametersNode (location: (34,13)-(34,14))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (313...314))
│ │ │ │ │ └── @ RequiredParameterNode (location: (34,13)-(34,14))
│ │ │ │ │ └── name: :_
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -340,38 +340,38 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (312...313) = "|"
│ │ │ └── closing_loc: (314...315) = "|"
│ │ │ ├── opening_loc: (34,12)-(34,13) = "|"
│ │ │ └── closing_loc: (34,14)-(34,15) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (309...311) = "do"
│ │ └── closing_loc: (318...321) = "end"
│ │ ├── opening_loc: (34,9)-(34,11) = "do"
│ │ └── closing_loc: (35,2)-(35,5) = "end"
│ ├── flags: ∅
│ └── name: "lambda"
├── consequent:
│ @ IfNode (location: (322...382))
│ ├── if_keyword_loc: (322...327) = "elsif"
│ @ IfNode (location: (36,0)-(42,3))
│ ├── if_keyword_loc: (36,0)-(36,5) = "elsif"
│ ├── predicate:
│ │ @ IntegerNode (location: (328...329))
│ │ @ IntegerNode (location: (36,6)-(36,7))
│ │ └── flags: decimal
│ ├── statements:
│ │ @ StatementsNode (location: (332...351))
│ │ @ StatementsNode (location: (37,2)-(38,5))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (332...351))
│ │ └── @ CallNode (location: (37,2)-(38,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (332...338) = "lambda"
│ │ ├── message_loc: (37,2)-(37,8) = "lambda"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block:
│ │ │ @ BlockNode (location: (339...351))
│ │ │ @ BlockNode (location: (37,9)-(38,5))
│ │ │ ├── locals: [:_]
│ │ │ ├── parameters:
│ │ │ │ @ BlockParametersNode (location: (342...345))
│ │ │ │ @ BlockParametersNode (location: (37,12)-(37,15))
│ │ │ │ ├── parameters:
│ │ │ │ │ @ ParametersNode (location: (343...344))
│ │ │ │ │ @ ParametersNode (location: (37,13)-(37,14))
│ │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ │ └── @ RequiredParameterNode (location: (343...344))
│ │ │ │ │ │ └── @ RequiredParameterNode (location: (37,13)-(37,14))
│ │ │ │ │ │ └── name: :_
│ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ ├── rest: ∅
@ -380,35 +380,35 @@
│ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ └── block: ∅
│ │ │ │ ├── locals: (length: 0)
│ │ │ │ ├── opening_loc: (342...343) = "|"
│ │ │ │ └── closing_loc: (344...345) = "|"
│ │ │ │ ├── opening_loc: (37,12)-(37,13) = "|"
│ │ │ │ └── closing_loc: (37,14)-(37,15) = "|"
│ │ │ ├── body: ∅
│ │ │ ├── opening_loc: (339...341) = "do"
│ │ │ └── closing_loc: (348...351) = "end"
│ │ │ ├── opening_loc: (37,9)-(37,11) = "do"
│ │ │ └── closing_loc: (38,2)-(38,5) = "end"
│ │ ├── flags: ∅
│ │ └── name: "lambda"
│ ├── consequent:
│ │ @ ElseNode (location: (352...382))
│ │ ├── else_keyword_loc: (352...356) = "else"
│ │ @ ElseNode (location: (39,0)-(42,3))
│ │ ├── else_keyword_loc: (39,0)-(39,4) = "else"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (359...378))
│ │ │ @ StatementsNode (location: (40,2)-(41,5))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (359...378))
│ │ │ └── @ CallNode (location: (40,2)-(41,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (359...365) = "lambda"
│ │ │ ├── message_loc: (40,2)-(40,8) = "lambda"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (366...378))
│ │ │ │ @ BlockNode (location: (40,9)-(41,5))
│ │ │ │ ├── locals: [:_]
│ │ │ │ ├── parameters:
│ │ │ │ │ @ BlockParametersNode (location: (369...372))
│ │ │ │ │ @ BlockParametersNode (location: (40,12)-(40,15))
│ │ │ │ │ ├── parameters:
│ │ │ │ │ │ @ ParametersNode (location: (370...371))
│ │ │ │ │ │ @ ParametersNode (location: (40,13)-(40,14))
│ │ │ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ │ │ └── @ RequiredParameterNode (location: (370...371))
│ │ │ │ │ │ │ └── @ RequiredParameterNode (location: (40,13)-(40,14))
│ │ │ │ │ │ │ └── name: :_
│ │ │ │ │ │ ├── optionals: (length: 0)
│ │ │ │ │ │ ├── rest: ∅
@ -417,13 +417,13 @@
│ │ │ │ │ │ ├── keyword_rest: ∅
│ │ │ │ │ │ └── block: ∅
│ │ │ │ │ ├── locals: (length: 0)
│ │ │ │ │ ├── opening_loc: (369...370) = "|"
│ │ │ │ │ └── closing_loc: (371...372) = "|"
│ │ │ │ │ ├── opening_loc: (40,12)-(40,13) = "|"
│ │ │ │ │ └── closing_loc: (40,14)-(40,15) = "|"
│ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (366...368) = "do"
│ │ │ │ └── closing_loc: (375...378) = "end"
│ │ │ │ ├── opening_loc: (40,9)-(40,11) = "do"
│ │ │ │ └── closing_loc: (41,2)-(41,5) = "end"
│ │ │ ├── flags: ∅
│ │ │ └── name: "lambda"
│ │ └── end_keyword_loc: (379...382) = "end"
│ └── end_keyword_loc: (379...382) = "end"
└── end_keyword_loc: (379...382) = "end"
│ │ └── end_keyword_loc: (42,0)-(42,3) = "end"
│ └── end_keyword_loc: (42,0)-(42,3) = "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: []
└── statements:
@ StatementsNode (location: (4...23))
@ StatementsNode (location: (1,4)-(3,7))
└── body: (length: 1)
└── @ DefNode (location: (4...23))
└── @ DefNode (location: (1,4)-(3,7))
├── name: :hi
├── name_loc: (8...10) = "hi"
├── name_loc: (1,8)-(1,10) = "hi"
├── receiver: ∅
├── parameters: ∅
├── body: ∅
├── locals: []
├── def_keyword_loc: (4...7) = "def"
├── def_keyword_loc: (1,4)-(1,7) = "def"
├── operator_loc: ∅
├── lparen_loc: ∅
├── rparen_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: []
└── statements:
@ StatementsNode (location: (0...247))
@ StatementsNode (location: (1,0)-(63,7))
└── body: (length: 32)
├── @ CallNode (location: (0...2))
├── @ CallNode (location: (1,0)-(1,2))
│ ├── receiver:
│ │ @ IntegerNode (location: (1...2))
│ │ @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "!"
│ ├── message_loc: (1,0)-(1,1) = "!"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
├── @ CallNode (location: (4...6))
├── @ CallNode (location: (3,0)-(3,2))
│ ├── receiver:
│ │ @ IntegerNode (location: (5...6))
│ │ @ IntegerNode (location: (3,1)-(3,2))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (4...5) = "~"
│ ├── message_loc: (3,0)-(3,1) = "~"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "~"
├── @ CallNode (location: (8...14))
├── @ CallNode (location: (5,0)-(5,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (8...9))
│ │ @ IntegerNode (location: (5,0)-(5,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (10...12) = "!="
│ ├── message_loc: (5,2)-(5,4) = "!="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (13...14))
│ │ @ ArgumentsNode (location: (5,5)-(5,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (13...14))
│ │ └── @ IntegerNode (location: (5,5)-(5,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!="
├── @ CallNode (location: (16...22))
├── @ CallNode (location: (7,0)-(7,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (16...17))
│ │ @ IntegerNode (location: (7,0)-(7,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (18...20) = "!~"
│ ├── message_loc: (7,2)-(7,4) = "!~"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (21...22))
│ │ @ ArgumentsNode (location: (7,5)-(7,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (21...22))
│ │ └── @ IntegerNode (location: (7,5)-(7,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!~"
├── @ CallNode (location: (24...29))
├── @ CallNode (location: (9,0)-(9,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (24...25))
│ │ @ IntegerNode (location: (9,0)-(9,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (26...27) = "%"
│ ├── message_loc: (9,2)-(9,3) = "%"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (28...29))
│ │ @ ArgumentsNode (location: (9,4)-(9,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (28...29))
│ │ └── @ IntegerNode (location: (9,4)-(9,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "%"
├── @ CallNode (location: (31...36))
├── @ CallNode (location: (11,0)-(11,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (31...32))
│ │ @ IntegerNode (location: (11,0)-(11,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (33...34) = "&"
│ ├── message_loc: (11,2)-(11,3) = "&"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (35...36))
│ │ @ ArgumentsNode (location: (11,4)-(11,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (35...36))
│ │ └── @ IntegerNode (location: (11,4)-(11,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "&"
├── @ CallNode (location: (38...43))
├── @ CallNode (location: (13,0)-(13,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (38...39))
│ │ @ IntegerNode (location: (13,0)-(13,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (40...41) = "*"
│ ├── message_loc: (13,2)-(13,3) = "*"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (42...43))
│ │ @ ArgumentsNode (location: (13,4)-(13,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (42...43))
│ │ └── @ IntegerNode (location: (13,4)-(13,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "*"
├── @ CallNode (location: (45...49))
├── @ CallNode (location: (15,0)-(15,4))
│ ├── receiver:
│ │ @ IntegerNode (location: (45...46))
│ │ @ IntegerNode (location: (15,0)-(15,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (46...48) = "**"
│ ├── message_loc: (15,1)-(15,3) = "**"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (48...49))
│ │ @ ArgumentsNode (location: (15,3)-(15,4))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (48...49))
│ │ └── @ IntegerNode (location: (15,3)-(15,4))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "**"
├── @ CallNode (location: (51...56))
├── @ CallNode (location: (17,0)-(17,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (51...52))
│ │ @ IntegerNode (location: (17,0)-(17,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (53...54) = "+"
│ ├── message_loc: (17,2)-(17,3) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (55...56))
│ │ @ ArgumentsNode (location: (17,4)-(17,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (55...56))
│ │ └── @ IntegerNode (location: (17,4)-(17,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
├── @ CallNode (location: (58...63))
├── @ CallNode (location: (19,0)-(19,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (58...59))
│ │ @ IntegerNode (location: (19,0)-(19,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (60...61) = "-"
│ ├── message_loc: (19,2)-(19,3) = "-"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (62...63))
│ │ @ ArgumentsNode (location: (19,4)-(19,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (62...63))
│ │ └── @ IntegerNode (location: (19,4)-(19,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "-"
├── @ CallNode (location: (65...70))
├── @ CallNode (location: (21,0)-(21,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (65...66))
│ │ @ IntegerNode (location: (21,0)-(21,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (67...68) = "/"
│ ├── message_loc: (21,2)-(21,3) = "/"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (69...70))
│ │ @ ArgumentsNode (location: (21,4)-(21,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (69...70))
│ │ └── @ IntegerNode (location: (21,4)-(21,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "/"
├── @ CallNode (location: (72...77))
├── @ CallNode (location: (23,0)-(23,5))
│ ├── receiver:
│ │ @ CallNode (location: (72...75))
│ │ @ CallNode (location: (23,0)-(23,3))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (72...73))
│ │ │ @ IntegerNode (location: (23,0)-(23,1))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (73...74) = "/"
│ │ ├── message_loc: (23,1)-(23,2) = "/"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (74...75))
│ │ │ @ ArgumentsNode (location: (23,2)-(23,3))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (74...75))
│ │ │ └── @ IntegerNode (location: (23,2)-(23,3))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "/"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (75...76) = "/"
│ ├── message_loc: (23,3)-(23,4) = "/"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (76...77))
│ │ @ ArgumentsNode (location: (23,4)-(23,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (76...77))
│ │ └── @ IntegerNode (location: (23,4)-(23,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "/"
├── @ CallNode (location: (79...84))
├── @ CallNode (location: (25,0)-(25,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (79...80))
│ │ @ IntegerNode (location: (25,0)-(25,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (81...82) = "<"
│ ├── message_loc: (25,2)-(25,3) = "<"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (83...84))
│ │ @ ArgumentsNode (location: (25,4)-(25,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (83...84))
│ │ └── @ IntegerNode (location: (25,4)-(25,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "<"
├── @ CallNode (location: (86...92))
├── @ CallNode (location: (27,0)-(27,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (86...87))
│ │ @ IntegerNode (location: (27,0)-(27,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (88...90) = "<<"
│ ├── message_loc: (27,2)-(27,4) = "<<"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (91...92))
│ │ @ ArgumentsNode (location: (27,5)-(27,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (91...92))
│ │ └── @ IntegerNode (location: (27,5)-(27,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "<<"
├── @ CallNode (location: (94...100))
├── @ CallNode (location: (29,0)-(29,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (94...95))
│ │ @ IntegerNode (location: (29,0)-(29,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (96...98) = "<="
│ ├── message_loc: (29,2)-(29,4) = "<="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (99...100))
│ │ @ ArgumentsNode (location: (29,5)-(29,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (99...100))
│ │ └── @ IntegerNode (location: (29,5)-(29,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "<="
├── @ CallNode (location: (102...109))
├── @ CallNode (location: (31,0)-(31,7))
│ ├── receiver:
│ │ @ IntegerNode (location: (102...103))
│ │ @ IntegerNode (location: (31,0)-(31,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (104...107) = "<=>"
│ ├── message_loc: (31,2)-(31,5) = "<=>"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (108...109))
│ │ @ ArgumentsNode (location: (31,6)-(31,7))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (108...109))
│ │ └── @ IntegerNode (location: (31,6)-(31,7))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "<=>"
├── @ CallNode (location: (111...117))
├── @ CallNode (location: (33,0)-(33,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (111...112))
│ │ @ IntegerNode (location: (33,0)-(33,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (113...115) = "=="
│ ├── message_loc: (33,2)-(33,4) = "=="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (116...117))
│ │ @ ArgumentsNode (location: (33,5)-(33,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (116...117))
│ │ └── @ IntegerNode (location: (33,5)-(33,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "=="
├── @ CallNode (location: (119...126))
├── @ CallNode (location: (35,0)-(35,7))
│ ├── receiver:
│ │ @ IntegerNode (location: (119...120))
│ │ @ IntegerNode (location: (35,0)-(35,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (121...124) = "==="
│ ├── message_loc: (35,2)-(35,5) = "==="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (125...126))
│ │ @ ArgumentsNode (location: (35,6)-(35,7))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (125...126))
│ │ └── @ IntegerNode (location: (35,6)-(35,7))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "==="
├── @ CallNode (location: (128...134))
├── @ CallNode (location: (37,0)-(37,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (128...129))
│ │ @ IntegerNode (location: (37,0)-(37,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (130...132) = "=~"
│ ├── message_loc: (37,2)-(37,4) = "=~"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (133...134))
│ │ @ ArgumentsNode (location: (37,5)-(37,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (133...134))
│ │ └── @ IntegerNode (location: (37,5)-(37,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "=~"
├── @ CallNode (location: (136...141))
├── @ CallNode (location: (39,0)-(39,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (136...137))
│ │ @ IntegerNode (location: (39,0)-(39,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (138...139) = ">"
│ ├── message_loc: (39,2)-(39,3) = ">"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (140...141))
│ │ @ ArgumentsNode (location: (39,4)-(39,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (140...141))
│ │ └── @ IntegerNode (location: (39,4)-(39,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: ">"
├── @ CallNode (location: (143...149))
├── @ CallNode (location: (41,0)-(41,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (143...144))
│ │ @ IntegerNode (location: (41,0)-(41,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (145...147) = ">="
│ ├── message_loc: (41,2)-(41,4) = ">="
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (148...149))
│ │ @ ArgumentsNode (location: (41,5)-(41,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (148...149))
│ │ └── @ IntegerNode (location: (41,5)-(41,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: ">="
├── @ CallNode (location: (151...157))
├── @ CallNode (location: (43,0)-(43,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (151...152))
│ │ @ IntegerNode (location: (43,0)-(43,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (153...155) = ">>"
│ ├── message_loc: (43,2)-(43,4) = ">>"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (156...157))
│ │ @ ArgumentsNode (location: (43,5)-(43,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (156...157))
│ │ └── @ IntegerNode (location: (43,5)-(43,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: ">>"
├── @ CallNode (location: (159...164))
├── @ CallNode (location: (45,0)-(45,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (159...160))
│ │ @ IntegerNode (location: (45,0)-(45,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (161...162) = "^"
│ ├── message_loc: (45,2)-(45,3) = "^"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (163...164))
│ │ @ ArgumentsNode (location: (45,4)-(45,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (163...164))
│ │ └── @ IntegerNode (location: (45,4)-(45,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "^"
├── @ CallNode (location: (166...171))
├── @ CallNode (location: (47,0)-(47,5))
│ ├── receiver:
│ │ @ IntegerNode (location: (166...167))
│ │ @ IntegerNode (location: (47,0)-(47,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (168...169) = "|"
│ ├── message_loc: (47,2)-(47,3) = "|"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (170...171))
│ │ @ ArgumentsNode (location: (47,4)-(47,5))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (170...171))
│ │ └── @ IntegerNode (location: (47,4)-(47,5))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "|"
├── @ AndNode (location: (173...179))
├── @ AndNode (location: (49,0)-(49,6))
│ ├── left:
│ │ @ IntegerNode (location: (173...174))
│ │ @ IntegerNode (location: (49,0)-(49,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (178...179))
│ │ @ IntegerNode (location: (49,5)-(49,6))
│ │ └── flags: decimal
│ └── operator_loc: (175...177) = "&&"
├── @ AndNode (location: (181...188))
│ └── operator_loc: (49,2)-(49,4) = "&&"
├── @ AndNode (location: (51,0)-(51,7))
│ ├── left:
│ │ @ IntegerNode (location: (181...182))
│ │ @ IntegerNode (location: (51,0)-(51,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (187...188))
│ │ @ IntegerNode (location: (51,6)-(51,7))
│ │ └── flags: decimal
│ └── operator_loc: (183...186) = "and"
├── @ CallNode (location: (190...200))
│ └── operator_loc: (51,2)-(51,5) = "and"
├── @ CallNode (location: (53,0)-(53,10))
│ ├── receiver:
│ │ @ IntegerNode (location: (190...191))
│ │ @ IntegerNode (location: (53,0)-(53,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (192...193) = "*"
│ ├── message_loc: (53,2)-(53,3) = "*"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (194...200))
│ │ @ ArgumentsNode (location: (53,4)-(53,10))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (194...200))
│ │ └── @ CallNode (location: (53,4)-(53,10))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (194...195))
│ │ │ @ IntegerNode (location: (53,4)-(53,5))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (196...198) = "**"
│ │ ├── message_loc: (53,6)-(53,8) = "**"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (199...200))
│ │ │ @ ArgumentsNode (location: (53,9)-(53,10))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (199...200))
│ │ │ └── @ IntegerNode (location: (53,9)-(53,10))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
@ -439,73 +439,73 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "*"
├── @ CallNode (location: (202...211))
├── @ CallNode (location: (55,0)-(55,9))
│ ├── receiver:
│ │ @ CallNode (location: (202...207))
│ │ @ CallNode (location: (55,0)-(55,5))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (202...203))
│ │ │ @ IntegerNode (location: (55,0)-(55,1))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (204...205) = "*"
│ │ ├── message_loc: (55,2)-(55,3) = "*"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (206...207))
│ │ │ @ ArgumentsNode (location: (55,4)-(55,5))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (206...207))
│ │ │ └── @ IntegerNode (location: (55,4)-(55,5))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "*"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (208...209) = "+"
│ ├── message_loc: (55,6)-(55,7) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (210...211))
│ │ @ ArgumentsNode (location: (55,8)-(55,9))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (210...211))
│ │ └── @ IntegerNode (location: (55,8)-(55,9))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
├── @ OrNode (location: (213...219))
├── @ OrNode (location: (57,0)-(57,6))
│ ├── left:
│ │ @ IntegerNode (location: (213...214))
│ │ @ IntegerNode (location: (57,0)-(57,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (218...219))
│ │ @ IntegerNode (location: (57,5)-(57,6))
│ │ └── flags: decimal
│ └── operator_loc: (215...217) = "or"
├── @ OrNode (location: (221...227))
│ └── operator_loc: (57,2)-(57,4) = "or"
├── @ OrNode (location: (59,0)-(59,6))
│ ├── left:
│ │ @ IntegerNode (location: (221...222))
│ │ @ IntegerNode (location: (59,0)-(59,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (226...227))
│ │ @ IntegerNode (location: (59,5)-(59,6))
│ │ └── flags: decimal
│ └── operator_loc: (223...225) = "||"
├── @ CallNode (location: (229...238))
│ └── operator_loc: (59,2)-(59,4) = "||"
├── @ CallNode (location: (61,0)-(61,9))
│ ├── receiver:
│ │ @ IntegerNode (location: (229...230))
│ │ @ IntegerNode (location: (61,0)-(61,1))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (231...232) = "+"
│ ├── message_loc: (61,2)-(61,3) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (233...238))
│ │ @ ArgumentsNode (location: (61,4)-(61,9))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (233...238))
│ │ └── @ CallNode (location: (61,4)-(61,9))
│ │ ├── receiver:
│ │ │ @ IntegerNode (location: (233...234))
│ │ │ @ IntegerNode (location: (61,4)-(61,5))
│ │ │ └── flags: decimal
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (235...236) = "*"
│ │ ├── message_loc: (61,6)-(61,7) = "*"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (237...238))
│ │ │ @ ArgumentsNode (location: (61,8)-(61,9))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (237...238))
│ │ │ └── @ IntegerNode (location: (61,8)-(61,9))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
@ -515,25 +515,25 @@
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
└── @ ParenthesesNode (location: (240...247))
└── @ ParenthesesNode (location: (63,0)-(63,7))
├── body:
│ @ StatementsNode (location: (241...246))
│ @ StatementsNode (location: (63,1)-(63,6))
│ └── body: (length: 1)
│ └── @ CallNode (location: (241...246))
│ └── @ CallNode (location: (63,1)-(63,6))
│ ├── receiver:
│ │ @ IntegerNode (location: (241...242))
│ │ @ IntegerNode (location: (63,1)-(63,2))
│ │ └── flags: decimal
│ ├── call_operator_loc: ∅
│ ├── message_loc: (243...244) = "+"
│ ├── message_loc: (63,3)-(63,4) = "+"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (245...246))
│ │ @ ArgumentsNode (location: (63,5)-(63,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (245...246))
│ │ └── @ IntegerNode (location: (63,5)-(63,6))
│ │ └── flags: decimal
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "+"
├── opening_loc: (240...241) = "("
└── closing_loc: (246...247) = ")"
├── opening_loc: (63,0)-(63,1) = "("
└── 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: []
└── statements:
@ StatementsNode (location: (0...185))
@ StatementsNode (location: (1,0)-(29,3))
└── body: (length: 10)
├── @ DefNode (location: (0...11))
├── @ DefNode (location: (1,0)-(2,3))
│ ├── name: :def
│ ├── name_loc: (4...7) = "def"
│ ├── name_loc: (1,4)-(1,7) = "def"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def"
│ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (8...11) = "end"
├── @ DefNode (location: (13...32))
│ └── end_keyword_loc: (2,0)-(2,3) = "end"
├── @ DefNode (location: (4,0)-(5,3))
│ ├── name: :ensure
│ ├── name_loc: (22...28) = "ensure"
│ ├── name_loc: (4,9)-(4,15) = "ensure"
│ ├── receiver:
│ │ @ SelfNode (location: (17...21))
│ │ @ SelfNode (location: (4,4)-(4,8))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (13...16) = "def"
│ ├── operator_loc: (21...22) = "."
│ ├── def_keyword_loc: (4,0)-(4,3) = "def"
│ ├── operator_loc: (4,8)-(4,9) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (29...32) = "end"
├── @ CallNode (location: (34...68))
│ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ CallNode (location: (7,0)-(10,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (34...41) = "private"
│ ├── message_loc: (7,0)-(7,7) = "private"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (42...68))
│ │ @ ArgumentsNode (location: (7,8)-(10,3))
│ │ └── arguments: (length: 1)
│ │ └── @ DefNode (location: (42...68))
│ │ └── @ DefNode (location: (7,8)-(10,3))
│ │ ├── name: :foo
│ │ ├── name_loc: (46...49) = "foo"
│ │ ├── name_loc: (7,12)-(7,15) = "foo"
│ │ ├── receiver: ∅
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (52...64))
│ │ │ @ StatementsNode (location: (8,2)-(9,5))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (52...64))
│ │ │ └── @ CallNode (location: (8,2)-(9,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (52...55) = "bar"
│ │ │ ├── message_loc: (8,2)-(8,5) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block:
│ │ │ │ @ BlockNode (location: (56...64))
│ │ │ │ @ BlockNode (location: (8,6)-(9,5))
│ │ │ │ ├── locals: []
│ │ │ │ ├── parameters: ∅
│ │ │ │ ├── body: ∅
│ │ │ │ ├── opening_loc: (56...58) = "do"
│ │ │ │ └── closing_loc: (61...64) = "end"
│ │ │ │ ├── opening_loc: (8,6)-(8,8) = "do"
│ │ │ │ └── closing_loc: (9,2)-(9,5) = "end"
│ │ │ ├── flags: ∅
│ │ │ └── name: "bar"
│ │ ├── locals: []
│ │ ├── def_keyword_loc: (42...45) = "def"
│ │ ├── def_keyword_loc: (7,8)-(7,11) = "def"
│ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: ∅
│ │ ├── rparen_loc: ∅
│ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (65...68) = "end"
│ │ └── end_keyword_loc: (10,0)-(10,3) = "end"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "private"
├── @ DefNode (location: (70...89))
├── @ DefNode (location: (12,0)-(13,3))
│ ├── name: :m
│ ├── name_loc: (74...75) = "m"
│ ├── name_loc: (12,4)-(12,5) = "m"
│ ├── receiver: ∅
│ ├── parameters:
│ │ @ ParametersNode (location: (76...84))
│ │ @ ParametersNode (location: (12,6)-(12,14))
│ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredParameterNode (location: (76...77))
│ │ │ └── @ RequiredParameterNode (location: (12,6)-(12,7))
│ │ │ └── name: :a
│ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅
│ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest:
│ │ │ @ NoKeywordsParameterNode (location: (79...84))
│ │ │ ├── operator_loc: (79...81) = "**"
│ │ │ └── keyword_loc: (81...84) = "nil"
│ │ │ @ NoKeywordsParameterNode (location: (12,9)-(12,14))
│ │ │ ├── operator_loc: (12,9)-(12,11) = "**"
│ │ │ └── keyword_loc: (12,11)-(12,14) = "nil"
│ │ └── block: ∅
│ ├── body: ∅
│ ├── locals: [:a]
│ ├── def_keyword_loc: (70...73) = "def"
│ ├── def_keyword_loc: (12,0)-(12,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: (75...76) = "("
│ ├── rparen_loc: (84...85) = ")"
│ ├── lparen_loc: (12,5)-(12,6) = "("
│ ├── rparen_loc: (12,14)-(12,15) = ")"
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (86...89) = "end"
├── @ DefNode (location: (91...113))
│ └── end_keyword_loc: (13,0)-(13,3) = "end"
├── @ DefNode (location: (15,0)-(16,3))
│ ├── name: :a
│ ├── name_loc: (108...109) = "a"
│ ├── name_loc: (15,17)-(15,18) = "a"
│ ├── receiver:
│ │ @ SourceEncodingNode (location: (95...107))
│ │ @ SourceEncodingNode (location: (15,4)-(15,16))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (91...94) = "def"
│ ├── operator_loc: (107...108) = "."
│ ├── def_keyword_loc: (15,0)-(15,3) = "def"
│ ├── operator_loc: (15,16)-(15,17) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (110...113) = "end"
├── @ StringNode (location: (115...121))
│ └── end_keyword_loc: (16,0)-(16,3) = "end"
├── @ StringNode (location: (18,0)-(18,6))
│ ├── flags: ∅
│ ├── opening_loc: (115...117) = "%{"
│ ├── content_loc: (117...120) = "abc"
│ ├── closing_loc: (120...121) = "}"
│ ├── opening_loc: (18,0)-(18,2) = "%{"
│ ├── content_loc: (18,2)-(18,5) = "abc"
│ ├── closing_loc: (18,5)-(18,6) = "}"
│ └── unescaped: "abc"
├── @ StringNode (location: (123...129))
├── @ StringNode (location: (20,0)-(20,6))
│ ├── flags: ∅
│ ├── opening_loc: (123...125) = "%\""
│ ├── content_loc: (125...128) = "abc"
│ ├── closing_loc: (128...129) = "\""
│ ├── opening_loc: (20,0)-(20,2) = "%\""
│ ├── content_loc: (20,2)-(20,5) = "abc"
│ ├── closing_loc: (20,5)-(20,6) = "\""
│ └── unescaped: "abc"
├── @ DefNode (location: (131...149))
├── @ DefNode (location: (22,0)-(23,3))
│ ├── name: :a
│ ├── name_loc: (144...145) = "a"
│ ├── name_loc: (22,13)-(22,14) = "a"
│ ├── receiver:
│ │ @ SourceFileNode (location: (135...143))
│ │ @ SourceFileNode (location: (22,4)-(22,12))
│ │ └── filepath: "keyword_method_names.txt"
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (131...134) = "def"
│ ├── operator_loc: (143...144) = "."
│ ├── def_keyword_loc: (22,0)-(22,3) = "def"
│ ├── operator_loc: (22,12)-(22,13) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (146...149) = "end"
├── @ DefNode (location: (151...169))
│ └── end_keyword_loc: (23,0)-(23,3) = "end"
├── @ DefNode (location: (25,0)-(26,3))
│ ├── name: :a
│ ├── name_loc: (164...165) = "a"
│ ├── name_loc: (25,13)-(25,14) = "a"
│ ├── receiver:
│ │ @ SourceLineNode (location: (155...163))
│ │ @ SourceLineNode (location: (25,4)-(25,12))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (151...154) = "def"
│ ├── operator_loc: (163...164) = "."
│ ├── def_keyword_loc: (25,0)-(25,3) = "def"
│ ├── operator_loc: (25,12)-(25,13) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (166...169) = "end"
└── @ DefNode (location: (171...185))
│ └── end_keyword_loc: (26,0)-(26,3) = "end"
└── @ DefNode (location: (28,0)-(29,3))
├── name: :a
├── name_loc: (180...181) = "a"
├── name_loc: (28,9)-(28,10) = "a"
├── receiver:
│ @ NilNode (location: (175...178))
│ @ NilNode (location: (28,4)-(28,7))
├── parameters: ∅
├── body: ∅
├── locals: []
├── def_keyword_loc: (171...174) = "def"
├── operator_loc: (178...180) = "::"
├── def_keyword_loc: (28,0)-(28,3) = "def"
├── operator_loc: (28,7)-(28,9) = "::"
├── lparen_loc: ∅
├── rparen_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: []
└── statements:
@ StatementsNode (location: (0...51))
@ StatementsNode (location: (1,0)-(11,8))
└── body: (length: 6)
├── @ RedoNode (location: (0...4))
├── @ RetryNode (location: (6...11))
├── @ SelfNode (location: (13...17))
├── @ SourceEncodingNode (location: (19...31))
├── @ SourceFileNode (location: (33...41))
├── @ RedoNode (location: (1,0)-(1,4))
├── @ RetryNode (location: (3,0)-(3,5))
├── @ SelfNode (location: (5,0)-(5,4))
├── @ SourceEncodingNode (location: (7,0)-(7,12))
├── @ SourceFileNode (location: (9,0)-(9,8))
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...92))
@ StatementsNode (location: (1,0)-(11,18))
└── body: (length: 5)
├── @ LambdaNode (location: (0...14))
├── @ LambdaNode (location: (1,0)-(3,4))
│ ├── locals: [:foo]
│ ├── operator_loc: (0...2) = "->"
│ ├── opening_loc: (12...13) = "{"
│ ├── closing_loc: (13...14) = "}"
│ ├── operator_loc: (1,0)-(1,2) = "->"
│ ├── opening_loc: (3,2)-(3,3) = "{"
│ ├── closing_loc: (3,3)-(3,4) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (2...11))
│ │ @ BlockParametersNode (location: (1,2)-(3,1))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (6...9))
│ │ │ @ ParametersNode (location: (2,2)-(2,5))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (6...9))
│ │ │ │ └── @ RequiredParameterNode (location: (2,2)-(2,5))
│ │ │ │ └── name: :foo
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -22,83 +22,83 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (2...3) = "("
│ │ └── closing_loc: (10...11) = ")"
│ │ ├── opening_loc: (1,2)-(1,3) = "("
│ │ └── closing_loc: (3,0)-(3,1) = ")"
│ └── body: ∅
├── @ LambdaNode (location: (16...34))
├── @ LambdaNode (location: (5,0)-(5,18))
│ ├── locals: [:x]
│ ├── operator_loc: (16...18) = "->"
│ ├── opening_loc: (31...32) = "{"
│ ├── closing_loc: (33...34) = "}"
│ ├── operator_loc: (5,0)-(5,2) = "->"
│ ├── opening_loc: (5,15)-(5,16) = "{"
│ ├── closing_loc: (5,17)-(5,18) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (18...30))
│ │ @ BlockParametersNode (location: (5,2)-(5,14))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (19...29))
│ │ │ @ ParametersNode (location: (5,3)-(5,13))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 1)
│ │ │ │ └── @ KeywordParameterNode (location: (19...29))
│ │ │ │ └── @ KeywordParameterNode (location: (5,3)-(5,13))
│ │ │ │ ├── name: :x
│ │ │ │ ├── name_loc: (19...21) = "x:"
│ │ │ │ ├── name_loc: (5,3)-(5,5) = "x:"
│ │ │ │ └── value:
│ │ │ │ @ InterpolatedStringNode (location: (22...29))
│ │ │ │ ├── opening_loc: (22...23) = "\""
│ │ │ │ @ InterpolatedStringNode (location: (5,6)-(5,13))
│ │ │ │ ├── opening_loc: (5,6)-(5,7) = "\""
│ │ │ │ ├── parts: (length: 2)
│ │ │ │ │ ├── @ StringNode (location: (23...24))
│ │ │ │ │ ├── @ StringNode (location: (5,7)-(5,8))
│ │ │ │ │ │ ├── flags: ∅
│ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── content_loc: (23...24) = "b"
│ │ │ │ │ │ ├── content_loc: (5,7)-(5,8) = "b"
│ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ └── unescaped: "b"
│ │ │ │ │ └── @ EmbeddedStatementsNode (location: (24...28))
│ │ │ │ │ ├── opening_loc: (24...26) = "\#{"
│ │ │ │ │ └── @ EmbeddedStatementsNode (location: (5,8)-(5,12))
│ │ │ │ │ ├── opening_loc: (5,8)-(5,10) = "\#{"
│ │ │ │ │ ├── statements:
│ │ │ │ │ │ @ StatementsNode (location: (26...27))
│ │ │ │ │ │ @ StatementsNode (location: (5,10)-(5,11))
│ │ │ │ │ │ └── body: (length: 1)
│ │ │ │ │ │ └── @ CallNode (location: (26...27))
│ │ │ │ │ │ └── @ CallNode (location: (5,10)-(5,11))
│ │ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ │ ├── message_loc: (26...27) = "a"
│ │ │ │ │ │ ├── message_loc: (5,10)-(5,11) = "a"
│ │ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ │ ├── block: ∅
│ │ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ │ └── name: "a"
│ │ │ │ │ └── closing_loc: (27...28) = "}"
│ │ │ │ └── closing_loc: (28...29) = "\""
│ │ │ │ │ └── closing_loc: (5,11)-(5,12) = "}"
│ │ │ │ └── closing_loc: (5,12)-(5,13) = "\""
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (18...19) = "("
│ │ └── closing_loc: (29...30) = ")"
│ │ ├── opening_loc: (5,2)-(5,3) = "("
│ │ └── closing_loc: (5,13)-(5,14) = ")"
│ └── body: ∅
├── @ LambdaNode (location: (36...51))
├── @ LambdaNode (location: (7,0)-(7,15))
│ ├── locals: [:a]
│ ├── operator_loc: (36...38) = "->"
│ ├── opening_loc: (49...50) = "{"
│ ├── closing_loc: (50...51) = "}"
│ ├── operator_loc: (7,0)-(7,2) = "->"
│ ├── opening_loc: (7,13)-(7,14) = "{"
│ ├── closing_loc: (7,14)-(7,15) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (38...48))
│ │ @ BlockParametersNode (location: (7,2)-(7,12))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (39...47))
│ │ │ @ ParametersNode (location: (7,3)-(7,11))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 1)
│ │ │ │ └── @ KeywordParameterNode (location: (39...47))
│ │ │ │ └── @ KeywordParameterNode (location: (7,3)-(7,11))
│ │ │ │ ├── name: :a
│ │ │ │ ├── name_loc: (39...41) = "a:"
│ │ │ │ ├── name_loc: (7,3)-(7,5) = "a:"
│ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (42...47))
│ │ │ │ @ CallNode (location: (7,6)-(7,11))
│ │ │ │ ├── receiver:
│ │ │ │ │ @ CallNode (location: (42...43))
│ │ │ │ │ @ CallNode (location: (7,6)-(7,7))
│ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (42...43) = "b"
│ │ │ │ │ ├── message_loc: (7,6)-(7,7) = "b"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
@ -106,12 +106,12 @@
│ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ └── name: "b"
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (44...45) = "*"
│ │ │ │ ├── message_loc: (7,8)-(7,9) = "*"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (46...47))
│ │ │ │ │ @ ArgumentsNode (location: (7,10)-(7,11))
│ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ IntegerNode (location: (46...47))
│ │ │ │ │ └── @ IntegerNode (location: (7,10)-(7,11))
│ │ │ │ │ └── flags: decimal
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
@ -120,29 +120,29 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (38...39) = "("
│ │ └── closing_loc: (47...48) = ")"
│ │ ├── opening_loc: (7,2)-(7,3) = "("
│ │ └── closing_loc: (7,11)-(7,12) = ")"
│ └── body: ∅
├── @ LambdaNode (location: (53...72))
├── @ LambdaNode (location: (9,0)-(9,19))
│ ├── locals: [:foo]
│ ├── operator_loc: (53...55) = "->"
│ ├── opening_loc: (66...68) = "do"
│ ├── closing_loc: (69...72) = "end"
│ ├── operator_loc: (9,0)-(9,2) = "->"
│ ├── opening_loc: (9,13)-(9,15) = "do"
│ ├── closing_loc: (9,16)-(9,19) = "end"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (56...65))
│ │ @ BlockParametersNode (location: (9,3)-(9,12))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (56...65))
│ │ │ @ ParametersNode (location: (9,3)-(9,12))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (56...65))
│ │ │ │ └── @ OptionalParameterNode (location: (9,3)-(9,12))
│ │ │ │ ├── name: :foo
│ │ │ │ ├── name_loc: (56...59) = "foo"
│ │ │ │ ├── operator_loc: (60...61) = "="
│ │ │ │ ├── name_loc: (9,3)-(9,6) = "foo"
│ │ │ │ ├── operator_loc: (9,7)-(9,8) = "="
│ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (62...65))
│ │ │ │ @ CallNode (location: (9,9)-(9,12))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (62...65) = "bar"
│ │ │ │ ├── message_loc: (9,9)-(9,12) = "bar"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -158,28 +158,28 @@
│ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅
│ └── body: ∅
└── @ LambdaNode (location: (74...92))
└── @ LambdaNode (location: (11,0)-(11,18))
├── locals: [:foo]
├── operator_loc: (74...76) = "->"
├── opening_loc: (86...88) = "do"
├── closing_loc: (89...92) = "end"
├── operator_loc: (11,0)-(11,2) = "->"
├── opening_loc: (11,12)-(11,14) = "do"
├── closing_loc: (11,15)-(11,18) = "end"
├── parameters:
│ @ BlockParametersNode (location: (77...85))
│ @ BlockParametersNode (location: (11,3)-(11,11))
│ ├── parameters:
│ │ @ ParametersNode (location: (77...85))
│ │ @ ParametersNode (location: (11,3)-(11,11))
│ │ ├── requireds: (length: 0)
│ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅
│ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 1)
│ │ │ └── @ KeywordParameterNode (location: (77...85))
│ │ │ └── @ KeywordParameterNode (location: (11,3)-(11,11))
│ │ │ ├── name: :foo
│ │ │ ├── name_loc: (77...81) = "foo:"
│ │ │ ├── name_loc: (11,3)-(11,7) = "foo:"
│ │ │ └── value:
│ │ │ @ CallNode (location: (82...85))
│ │ │ @ CallNode (location: (11,8)-(11,11))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (82...85) = "bar"
│ │ │ ├── message_loc: (11,8)-(11,11) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── 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: []
└── statements:
@ StatementsNode (location: (0...140))
@ StatementsNode (location: (1,0)-(18,3))
└── body: (length: 7)
├── @ ModuleNode (location: (0...18))
├── @ ModuleNode (location: (1,0)-(1,18))
│ ├── locals: [:a]
│ ├── module_keyword_loc: (0...6) = "module"
│ ├── module_keyword_loc: (1,0)-(1,6) = "module"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (7...8))
│ │ @ ConstantReadNode (location: (1,7)-(1,8))
│ │ └── name: :A
│ ├── body:
│ │ @ StatementsNode (location: (9...14))
│ │ @ StatementsNode (location: (1,9)-(1,14))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableWriteNode (location: (9...14))
│ │ └── @ LocalVariableWriteNode (location: (1,9)-(1,14))
│ │ ├── name: :a
│ │ ├── depth: 0
│ │ ├── name_loc: (9...10) = "a"
│ │ ├── name_loc: (1,9)-(1,10) = "a"
│ │ ├── value:
│ │ │ @ IntegerNode (location: (13...14))
│ │ │ @ IntegerNode (location: (1,13)-(1,14))
│ │ │ └── flags: decimal
│ │ └── operator_loc: (11...12) = "="
│ ├── end_keyword_loc: (15...18) = "end"
│ │ └── operator_loc: (1,11)-(1,12) = "="
│ ├── end_keyword_loc: (1,15)-(1,18) = "end"
│ └── name: :A
├── @ InterpolatedStringNode (location: (20...38))
│ ├── opening_loc: (20...23) = "%Q{"
├── @ InterpolatedStringNode (location: (3,0)-(3,18))
│ ├── opening_loc: (3,0)-(3,3) = "%Q{"
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (23...27))
│ │ ├── @ StringNode (location: (3,3)-(3,7))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (23...27) = "aaa "
│ │ │ ├── content_loc: (3,3)-(3,7) = "aaa "
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa "
│ │ ├── @ EmbeddedStatementsNode (location: (27...33))
│ │ │ ├── opening_loc: (27...29) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (3,7)-(3,13))
│ │ │ ├── opening_loc: (3,7)-(3,9) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (29...32))
│ │ │ │ @ StatementsNode (location: (3,9)-(3,12))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (29...32))
│ │ │ │ └── @ CallNode (location: (3,9)-(3,12))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (29...32) = "bbb"
│ │ │ │ ├── message_loc: (3,9)-(3,12) = "bbb"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bbb"
│ │ │ └── closing_loc: (32...33) = "}"
│ │ └── @ StringNode (location: (33...37))
│ │ │ └── closing_loc: (3,12)-(3,13) = "}"
│ │ └── @ StringNode (location: (3,13)-(3,17))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (33...37) = " ccc"
│ │ ├── content_loc: (3,13)-(3,17) = " ccc"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: " ccc"
│ └── closing_loc: (37...38) = "}"
├── @ ModuleNode (location: (40...55))
│ └── closing_loc: (3,17)-(3,18) = "}"
├── @ ModuleNode (location: (5,0)-(6,3))
│ ├── locals: []
│ ├── module_keyword_loc: (40...46) = "module"
│ ├── module_keyword_loc: (5,0)-(5,6) = "module"
│ ├── constant_path:
│ │ @ ConstantPathNode (location: (47...51))
│ │ @ ConstantPathNode (location: (5,7)-(5,11))
│ │ ├── parent:
│ │ │ @ CallNode (location: (47...48))
│ │ │ @ CallNode (location: (5,7)-(5,8))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (47...48) = "m"
│ │ │ ├── message_loc: (5,7)-(5,8) = "m"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -71,35 +71,35 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "m"
│ │ ├── child:
│ │ │ @ ConstantReadNode (location: (50...51))
│ │ │ @ ConstantReadNode (location: (5,10)-(5,11))
│ │ │ └── name: :M
│ │ └── delimiter_loc: (48...50) = "::"
│ │ └── delimiter_loc: (5,8)-(5,10) = "::"
│ ├── body: ∅
│ ├── end_keyword_loc: (52...55) = "end"
│ ├── end_keyword_loc: (6,0)-(6,3) = "end"
│ └── name: :M
├── @ ModuleNode (location: (57...85))
├── @ ModuleNode (location: (8,0)-(9,19))
│ ├── locals: [:x]
│ ├── module_keyword_loc: (57...63) = "module"
│ ├── module_keyword_loc: (8,0)-(8,6) = "module"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (64...65))
│ │ @ ConstantReadNode (location: (8,7)-(8,8))
│ │ └── name: :A
│ ├── body:
│ │ @ BeginNode (location: (67...85))
│ │ @ BeginNode (location: (9,1)-(9,19))
│ │ ├── begin_keyword_loc: ∅
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (67...72))
│ │ │ @ StatementsNode (location: (9,1)-(9,6))
│ │ │ └── body: (length: 1)
│ │ │ └── @ LocalVariableWriteNode (location: (67...72))
│ │ │ └── @ LocalVariableWriteNode (location: (9,1)-(9,6))
│ │ │ ├── name: :x
│ │ │ ├── depth: 0
│ │ │ ├── name_loc: (67...68) = "x"
│ │ │ ├── name_loc: (9,1)-(9,2) = "x"
│ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (71...72))
│ │ │ │ @ IntegerNode (location: (9,5)-(9,6))
│ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (69...70) = "="
│ │ │ └── operator_loc: (9,3)-(9,4) = "="
│ │ ├── rescue_clause:
│ │ │ @ RescueNode (location: (74...80))
│ │ │ ├── keyword_loc: (74...80) = "rescue"
│ │ │ @ RescueNode (location: (9,8)-(9,14))
│ │ │ ├── keyword_loc: (9,8)-(9,14) = "rescue"
│ │ │ ├── exceptions: (length: 0)
│ │ │ ├── operator_loc: ∅
│ │ │ ├── reference: ∅
@ -107,73 +107,73 @@
│ │ │ └── consequent: ∅
│ │ ├── else_clause: ∅
│ │ ├── ensure_clause: ∅
│ │ └── end_keyword_loc: (82...85) = "end"
│ ├── end_keyword_loc: (82...85) = "end"
│ │ └── end_keyword_loc: (9,16)-(9,19) = "end"
│ ├── end_keyword_loc: (9,16)-(9,19) = "end"
│ └── name: :A
├── @ ModuleNode (location: (87...101))
├── @ ModuleNode (location: (11,0)-(12,3))
│ ├── locals: []
│ ├── module_keyword_loc: (87...93) = "module"
│ ├── module_keyword_loc: (11,0)-(11,6) = "module"
│ ├── constant_path:
│ │ @ ConstantPathNode (location: (94...97))
│ │ @ ConstantPathNode (location: (11,7)-(11,10))
│ │ ├── parent: ∅
│ │ ├── child:
│ │ │ @ ConstantReadNode (location: (96...97))
│ │ │ @ ConstantReadNode (location: (11,9)-(11,10))
│ │ │ └── name: :A
│ │ └── delimiter_loc: (94...96) = "::"
│ │ └── delimiter_loc: (11,7)-(11,9) = "::"
│ ├── body: ∅
│ ├── end_keyword_loc: (98...101) = "end"
│ ├── end_keyword_loc: (12,0)-(12,3) = "end"
│ └── name: :A
├── @ ModuleNode (location: (103...120))
├── @ ModuleNode (location: (14,0)-(15,3))
│ ├── locals: []
│ ├── module_keyword_loc: (103...109) = "module"
│ ├── module_keyword_loc: (14,0)-(14,6) = "module"
│ ├── constant_path:
│ │ @ ConstantPathNode (location: (110...116))
│ │ @ ConstantPathNode (location: (14,7)-(14,13))
│ │ ├── parent:
│ │ │ @ CallNode (location: (110...113))
│ │ │ @ CallNode (location: (14,7)-(14,10))
│ │ │ ├── receiver:
│ │ │ │ @ ConstantReadNode (location: (110...111))
│ │ │ │ @ ConstantReadNode (location: (14,7)-(14,8))
│ │ │ │ └── name: :A
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (111...113) = "[]"
│ │ │ ├── opening_loc: (111...112) = "["
│ │ │ ├── message_loc: (14,8)-(14,10) = "[]"
│ │ │ ├── opening_loc: (14,8)-(14,9) = "["
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: (112...113) = "]"
│ │ │ ├── closing_loc: (14,9)-(14,10) = "]"
│ │ │ ├── block: ∅
│ │ │ ├── flags: ∅
│ │ │ └── name: "[]"
│ │ ├── child:
│ │ │ @ ConstantReadNode (location: (115...116))
│ │ │ @ ConstantReadNode (location: (14,12)-(14,13))
│ │ │ └── name: :B
│ │ └── delimiter_loc: (113...115) = "::"
│ │ └── delimiter_loc: (14,10)-(14,12) = "::"
│ ├── body: ∅
│ ├── end_keyword_loc: (117...120) = "end"
│ ├── end_keyword_loc: (15,0)-(15,3) = "end"
│ └── name: :B
└── @ ModuleNode (location: (122...140))
└── @ ModuleNode (location: (17,0)-(18,3))
├── locals: []
├── module_keyword_loc: (122...128) = "module"
├── module_keyword_loc: (17,0)-(17,6) = "module"
├── constant_path:
│ @ ConstantPathNode (location: (129...136))
│ @ ConstantPathNode (location: (17,7)-(17,14))
│ ├── parent:
│ │ @ CallNode (location: (129...133))
│ │ @ CallNode (location: (17,7)-(17,11))
│ │ ├── receiver:
│ │ │ @ ConstantReadNode (location: (129...130))
│ │ │ @ ConstantReadNode (location: (17,7)-(17,8))
│ │ │ └── name: :A
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (130...133) = "[1]"
│ │ ├── opening_loc: (130...131) = "["
│ │ ├── message_loc: (17,8)-(17,11) = "[1]"
│ │ ├── opening_loc: (17,8)-(17,9) = "["
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (131...132))
│ │ │ @ ArgumentsNode (location: (17,9)-(17,10))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ IntegerNode (location: (131...132))
│ │ │ └── @ IntegerNode (location: (17,9)-(17,10))
│ │ │ └── flags: decimal
│ │ ├── closing_loc: (132...133) = "]"
│ │ ├── closing_loc: (17,10)-(17,11) = "]"
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "[]"
│ ├── child:
│ │ @ ConstantReadNode (location: (135...136))
│ │ @ ConstantReadNode (location: (17,13)-(17,14))
│ │ └── name: :B
│ └── delimiter_loc: (133...135) = "::"
│ └── delimiter_loc: (17,11)-(17,13) = "::"
├── body: ∅
├── end_keyword_loc: (137...140) = "end"
├── end_keyword_loc: (18,0)-(18,3) = "end"
└── 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: []
└── statements:
@ StatementsNode (location: (76...212))
@ StatementsNode (location: (3,0)-(40,0))
└── body: (length: 17)
├── @ StringNode (location: (76...82))
├── @ StringNode (location: (3,0)-(3,6))
│ ├── flags: ∅
│ ├── opening_loc: (76...78) = "% "
│ ├── content_loc: (78...81) = "abc"
│ ├── closing_loc: (81...82) = " "
│ ├── opening_loc: (3,0)-(3,2) = "% "
│ ├── content_loc: (3,2)-(3,5) = "abc"
│ ├── closing_loc: (3,5)-(3,6) = " "
│ └── unescaped: "abc"
├── @ StringNode (location: (84...90))
├── @ StringNode (location: (4,0)-(4,6))
│ ├── flags: ∅
│ ├── opening_loc: (84...86) = "%\t"
│ ├── content_loc: (86...89) = "abc"
│ ├── closing_loc: (89...90) = "\t"
│ ├── opening_loc: (4,0)-(4,2) = "%\t"
│ ├── content_loc: (4,2)-(4,5) = "abc"
│ ├── closing_loc: (4,5)-(4,6) = "\t"
│ └── unescaped: "abc"
├── @ StringNode (location: (92...98))
├── @ StringNode (location: (5,0)-(5,6))
│ ├── flags: ∅
│ ├── opening_loc: (92...94) = "%\v"
│ ├── content_loc: (94...97) = "abc"
│ ├── closing_loc: (97...98) = "\v"
│ ├── opening_loc: (5,0)-(5,2) = "%\v"
│ ├── content_loc: (5,2)-(5,5) = "abc"
│ ├── closing_loc: (5,5)-(5,6) = "\v"
│ └── unescaped: "abc"
├── @ StringNode (location: (100...106))
├── @ StringNode (location: (6,0)-(6,6))
│ ├── flags: ∅
│ ├── opening_loc: (100...102) = "%\r"
│ ├── content_loc: (102...105) = "abc"
│ ├── closing_loc: (105...106) = "\r"
│ ├── opening_loc: (6,0)-(6,2) = "%\r"
│ ├── content_loc: (6,2)-(6,5) = "abc"
│ ├── closing_loc: (6,5)-(6,6) = "\r"
│ └── unescaped: "abc"
├── @ StringNode (location: (108...114))
├── @ StringNode (location: (7,0)-(8,0))
│ ├── flags: ∅
│ ├── opening_loc: (108...110) = "%\n"
│ ├── content_loc: (110...113) = "abc"
│ ├── closing_loc: (113...114) = "\n"
│ ├── opening_loc: (7,0)-(7,0) = "%\n"
│ ├── content_loc: (8,0)-(8,3) = "abc"
│ ├── closing_loc: (8,3)-(8,0) = "\n"
│ └── unescaped: "abc"
├── @ StringNode (location: (116...122))
├── @ StringNode (location: (10,0)-(10,6))
│ ├── flags: ∅
│ ├── opening_loc: (116...118) = "%\u0000"
│ ├── content_loc: (118...121) = "abc"
│ ├── closing_loc: (121...122) = "\u0000"
│ ├── opening_loc: (10,0)-(10,2) = "%\u0000"
│ ├── content_loc: (10,2)-(10,5) = "abc"
│ ├── closing_loc: (10,5)-(10,6) = "\u0000"
│ └── unescaped: "abc"
├── @ StringNode (location: (124...130))
├── @ StringNode (location: (11,0)-(12,0))
│ ├── flags: ∅
│ ├── opening_loc: (124...126) = "%\n"
│ ├── content_loc: (126...129) = "abc"
│ ├── closing_loc: (129...130) = "\n"
│ ├── opening_loc: (11,0)-(11,0) = "%\n"
│ ├── content_loc: (12,0)-(12,3) = "abc"
│ ├── closing_loc: (12,3)-(12,0) = "\n"
│ └── unescaped: "abc"
├── @ StringNode (location: (132...139))
├── @ StringNode (location: (14,0)-(15,0))
│ ├── flags: ∅
│ ├── opening_loc: (132...134) = "%\n"
│ ├── content_loc: (134...138) = "\rabc"
│ ├── closing_loc: (138...139) = "\n"
│ ├── opening_loc: (14,0)-(14,0) = "%\n"
│ ├── content_loc: (15,0)-(15,4) = "\rabc"
│ ├── closing_loc: (15,4)-(15,0) = "\n"
│ └── unescaped: "\rabc"
├── @ StringNode (location: (142...149))
├── @ StringNode (location: (17,0)-(18,0))
│ ├── flags: ∅
│ ├── opening_loc: (142...144) = "%\n"
│ ├── content_loc: (144...148) = "\rabc"
│ ├── closing_loc: (148...149) = "\n"
│ ├── opening_loc: (17,0)-(17,0) = "%\n"
│ ├── content_loc: (18,0)-(18,4) = "\rabc"
│ ├── closing_loc: (18,4)-(18,0) = "\n"
│ └── unescaped: "\rabc"
├── @ StringNode (location: (151...157))
├── @ StringNode (location: (20,0)-(21,0))
│ ├── flags: ∅
│ ├── opening_loc: (151...153) = "%\n"
│ ├── content_loc: (153...156) = "abc"
│ ├── closing_loc: (156...157) = "\n"
│ ├── opening_loc: (20,0)-(20,0) = "%\n"
│ ├── content_loc: (21,0)-(21,3) = "abc"
│ ├── closing_loc: (21,3)-(21,0) = "\n"
│ └── unescaped: "abc"
├── @ StringNode (location: (159...165))
├── @ StringNode (location: (23,0)-(23,6))
│ ├── flags: ∅
│ ├── opening_loc: (159...161) = "%\r"
│ ├── content_loc: (161...164) = "abc"
│ ├── closing_loc: (164...165) = "\r"
│ ├── opening_loc: (23,0)-(23,2) = "%\r"
│ ├── content_loc: (23,2)-(23,5) = "abc"
│ ├── closing_loc: (23,5)-(23,6) = "\r"
│ └── unescaped: "abc"
├── @ StringNode (location: (167...173))
├── @ StringNode (location: (24,0)-(25,0))
│ ├── flags: ∅
│ ├── opening_loc: (167...169) = "%\n"
│ ├── content_loc: (169...172) = "abc"
│ ├── closing_loc: (172...173) = "\n"
│ ├── opening_loc: (24,0)-(24,0) = "%\n"
│ ├── content_loc: (25,0)-(25,3) = "abc"
│ ├── closing_loc: (25,3)-(25,0) = "\n"
│ └── unescaped: "abc"
├── @ StringNode (location: (175...181))
├── @ StringNode (location: (27,0)-(28,0))
│ ├── flags: ∅
│ ├── opening_loc: (175...177) = "%\n"
│ ├── content_loc: (177...180) = "abc"
│ ├── closing_loc: (180...181) = "\n"
│ ├── opening_loc: (27,0)-(27,0) = "%\n"
│ ├── content_loc: (28,0)-(28,3) = "abc"
│ ├── closing_loc: (28,3)-(28,0) = "\n"
│ └── unescaped: "abc"
├── @ StringNode (location: (182...188))
├── @ StringNode (location: (30,0)-(31,0))
│ ├── flags: ∅
│ ├── opening_loc: (182...184) = "%\n"
│ ├── content_loc: (184...187) = "foo"
│ ├── closing_loc: (187...188) = "\n"
│ ├── opening_loc: (30,0)-(30,0) = "%\n"
│ ├── content_loc: (31,0)-(31,3) = "foo"
│ ├── closing_loc: (31,3)-(31,0) = "\n"
│ └── unescaped: "foo"
├── @ StringNode (location: (189...196))
├── @ StringNode (location: (33,0)-(34,0))
│ ├── flags: ∅
│ ├── opening_loc: (189...192) = "%q\n"
│ ├── content_loc: (192...195) = "foo"
│ ├── closing_loc: (195...196) = "\n"
│ ├── opening_loc: (33,0)-(33,0) = "%q\n"
│ ├── content_loc: (34,0)-(34,3) = "foo"
│ ├── closing_loc: (34,3)-(34,0) = "\n"
│ └── unescaped: "foo"
├── @ StringNode (location: (197...204))
├── @ StringNode (location: (36,0)-(37,0))
│ ├── flags: ∅
│ ├── opening_loc: (197...200) = "%Q\n"
│ ├── content_loc: (200...203) = "foo"
│ ├── closing_loc: (203...204) = "\n"
│ ├── opening_loc: (36,0)-(36,0) = "%Q\n"
│ ├── content_loc: (37,0)-(37,3) = "foo"
│ ├── closing_loc: (37,3)-(37,0) = "\n"
│ └── unescaped: "foo"
└── @ RegularExpressionNode (location: (205...212))
├── opening_loc: (205...208) = "%r\n"
├── content_loc: (208...211) = "foo"
├── closing_loc: (211...212) = "\n"
└── @ RegularExpressionNode (location: (39,0)-(40,0))
├── opening_loc: (39,0)-(39,0) = "%r\n"
├── content_loc: (40,0)-(40,3) = "foo"
├── closing_loc: (40,3)-(40,0) = "\n"
├── unescaped: "foo"
└── flags: ∅

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

@ -1,123 +1,123 @@
@ ProgramNode (location: (0...118))
@ ProgramNode (location: (1,0)-(24,7))
├── locals: []
└── statements:
@ StatementsNode (location: (0...118))
@ StatementsNode (location: (1,0)-(24,7))
└── body: (length: 11)
├── @ NextNode (location: (0...4))
├── @ NextNode (location: (1,0)-(1,4))
│ ├── arguments: ∅
│ └── keyword_loc: (0...4) = "next"
├── @ NextNode (location: (6...24))
│ └── keyword_loc: (1,0)-(1,4) = "next"
├── @ NextNode (location: (3,0)-(3,18))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (11...24))
│ │ @ ArgumentsNode (location: (3,5)-(3,18))
│ │ └── arguments: (length: 3)
│ │ ├── @ ParenthesesNode (location: (11...14))
│ │ ├── @ ParenthesesNode (location: (3,5)-(3,8))
│ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (12...13))
│ │ │ │ @ StatementsNode (location: (3,6)-(3,7))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (12...13))
│ │ │ │ └── @ IntegerNode (location: (3,6)-(3,7))
│ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (11...12) = "("
│ │ │ └── closing_loc: (13...14) = ")"
│ │ ├── @ ParenthesesNode (location: (16...19))
│ │ │ ├── opening_loc: (3,5)-(3,6) = "("
│ │ │ └── closing_loc: (3,7)-(3,8) = ")"
│ │ ├── @ ParenthesesNode (location: (3,10)-(3,13))
│ │ │ ├── body:
│ │ │ │ @ StatementsNode (location: (17...18))
│ │ │ │ @ StatementsNode (location: (3,11)-(3,12))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ IntegerNode (location: (17...18))
│ │ │ │ └── @ IntegerNode (location: (3,11)-(3,12))
│ │ │ │ └── flags: decimal
│ │ │ ├── opening_loc: (16...17) = "("
│ │ │ └── closing_loc: (18...19) = ")"
│ │ └── @ ParenthesesNode (location: (21...24))
│ │ │ ├── opening_loc: (3,10)-(3,11) = "("
│ │ │ └── closing_loc: (3,12)-(3,13) = ")"
│ │ └── @ ParenthesesNode (location: (3,15)-(3,18))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (22...23))
│ │ │ @ StatementsNode (location: (3,16)-(3,17))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (22...23))
│ │ │ └── @ IntegerNode (location: (3,16)-(3,17))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (21...22) = "("
│ │ └── closing_loc: (23...24) = ")"
│ └── keyword_loc: (6...10) = "next"
├── @ NextNode (location: (26...32))
│ │ ├── opening_loc: (3,15)-(3,16) = "("
│ │ └── closing_loc: (3,17)-(3,18) = ")"
│ └── keyword_loc: (3,0)-(3,4) = "next"
├── @ NextNode (location: (5,0)-(5,6))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (31...32))
│ │ @ ArgumentsNode (location: (5,5)-(5,6))
│ │ └── arguments: (length: 1)
│ │ └── @ IntegerNode (location: (31...32))
│ │ └── @ IntegerNode (location: (5,5)-(5,6))
│ │ └── flags: decimal
│ └── keyword_loc: (26...30) = "next"
├── @ NextNode (location: (34...46))
│ └── keyword_loc: (5,0)-(5,4) = "next"
├── @ NextNode (location: (7,0)-(8,1))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (39...46))
│ │ @ ArgumentsNode (location: (7,5)-(8,1))
│ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (39...40))
│ │ ├── @ IntegerNode (location: (7,5)-(7,6))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (42...43))
│ │ ├── @ IntegerNode (location: (7,8)-(7,9))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (45...46))
│ │ └── @ IntegerNode (location: (8,0)-(8,1))
│ │ └── flags: decimal
│ └── keyword_loc: (34...38) = "next"
├── @ NextNode (location: (48...60))
│ └── keyword_loc: (7,0)-(7,4) = "next"
├── @ NextNode (location: (10,0)-(10,12))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (53...60))
│ │ @ ArgumentsNode (location: (10,5)-(10,12))
│ │ └── arguments: (length: 3)
│ │ ├── @ IntegerNode (location: (53...54))
│ │ ├── @ IntegerNode (location: (10,5)-(10,6))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (56...57))
│ │ ├── @ IntegerNode (location: (10,8)-(10,9))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (59...60))
│ │ └── @ IntegerNode (location: (10,11)-(10,12))
│ │ └── flags: decimal
│ └── keyword_loc: (48...52) = "next"
├── @ NextNode (location: (62...76))
│ └── keyword_loc: (10,0)-(10,4) = "next"
├── @ NextNode (location: (12,0)-(12,14))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (67...76))
│ │ @ ArgumentsNode (location: (12,5)-(12,14))
│ │ └── arguments: (length: 1)
│ │ └── @ ArrayNode (location: (67...76))
│ │ └── @ ArrayNode (location: (12,5)-(12,14))
│ │ ├── elements: (length: 3)
│ │ │ ├── @ IntegerNode (location: (68...69))
│ │ │ ├── @ IntegerNode (location: (12,6)-(12,7))
│ │ │ │ └── flags: decimal
│ │ │ ├── @ IntegerNode (location: (71...72))
│ │ │ ├── @ IntegerNode (location: (12,9)-(12,10))
│ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (74...75))
│ │ │ └── @ IntegerNode (location: (12,12)-(12,13))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (67...68) = "["
│ │ └── closing_loc: (75...76) = "]"
│ └── keyword_loc: (62...66) = "next"
├── @ NextNode (location: (78...93))
│ │ ├── opening_loc: (12,5)-(12,6) = "["
│ │ └── closing_loc: (12,13)-(12,14) = "]"
│ └── keyword_loc: (12,0)-(12,4) = "next"
├── @ NextNode (location: (14,0)-(17,1))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (82...93))
│ │ @ ArgumentsNode (location: (14,4)-(17,1))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (82...93))
│ │ └── @ ParenthesesNode (location: (14,4)-(17,1))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (86...91))
│ │ │ @ StatementsNode (location: (15,2)-(16,3))
│ │ │ └── body: (length: 2)
│ │ │ ├── @ IntegerNode (location: (86...87))
│ │ │ ├── @ IntegerNode (location: (15,2)-(15,3))
│ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (90...91))
│ │ │ └── @ IntegerNode (location: (16,2)-(16,3))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (82...83) = "("
│ │ └── closing_loc: (92...93) = ")"
│ └── keyword_loc: (78...82) = "next"
├── @ NextNode (location: (95...99))
│ │ ├── opening_loc: (14,4)-(14,5) = "("
│ │ └── closing_loc: (17,0)-(17,1) = ")"
│ └── keyword_loc: (14,0)-(14,4) = "next"
├── @ NextNode (location: (19,0)-(19,4))
│ ├── arguments: ∅
│ └── keyword_loc: (95...99) = "next"
├── @ IntegerNode (location: (100...101))
│ └── keyword_loc: (19,0)-(19,4) = "next"
├── @ IntegerNode (location: (20,0)-(20,1))
│ └── flags: decimal
├── @ NextNode (location: (103...109))
├── @ NextNode (location: (22,0)-(22,6))
│ ├── arguments:
│ │ @ ArgumentsNode (location: (107...109))
│ │ @ ArgumentsNode (location: (22,4)-(22,6))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (107...109))
│ │ └── @ ParenthesesNode (location: (22,4)-(22,6))
│ │ ├── body: ∅
│ │ ├── opening_loc: (107...108) = "("
│ │ └── closing_loc: (108...109) = ")"
│ └── keyword_loc: (103...107) = "next"
└── @ NextNode (location: (111...118))
│ │ ├── opening_loc: (22,4)-(22,5) = "("
│ │ └── closing_loc: (22,5)-(22,6) = ")"
│ └── keyword_loc: (22,0)-(22,4) = "next"
└── @ NextNode (location: (24,0)-(24,7))
├── arguments:
│ @ ArgumentsNode (location: (115...118))
│ @ ArgumentsNode (location: (24,4)-(24,7))
│ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (115...118))
│ └── @ ParenthesesNode (location: (24,4)-(24,7))
│ ├── body:
│ │ @ StatementsNode (location: (116...117))
│ │ @ StatementsNode (location: (24,5)-(24,6))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (116...117))
│ │ └── @ IntegerNode (location: (24,5)-(24,6))
│ │ └── flags: decimal
│ ├── opening_loc: (115...116) = "("
│ └── closing_loc: (117...118) = ")"
└── keyword_loc: (111...115) = "next"
│ ├── opening_loc: (24,4)-(24,5) = "("
│ └── closing_loc: (24,6)-(24,7) = ")"
└── 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: []
└── statements:
@ StatementsNode (location: (0...40))
@ StatementsNode (location: (1,0)-(12,11))
└── body: (length: 5)
├── @ NilNode (location: (0...3))
├── @ ParenthesesNode (location: (5...7))
├── @ NilNode (location: (1,0)-(1,3))
├── @ ParenthesesNode (location: (3,0)-(3,2))
│ ├── body: ∅
│ ├── opening_loc: (5...6) = "("
│ └── closing_loc: (6...7) = ")"
├── @ ParenthesesNode (location: (9...16))
│ ├── opening_loc: (3,0)-(3,1) = "("
│ └── closing_loc: (3,1)-(3,2) = ")"
├── @ ParenthesesNode (location: (5,0)-(8,1))
│ ├── body: ∅
│ ├── opening_loc: (9...10) = "("
│ └── closing_loc: (15...16) = ")"
├── @ PostExecutionNode (location: (18...27))
│ ├── opening_loc: (5,0)-(5,1) = "("
│ └── closing_loc: (8,0)-(8,1) = ")"
├── @ PostExecutionNode (location: (10,0)-(10,9))
│ ├── statements:
│ │ @ StatementsNode (location: (24...25))
│ │ @ StatementsNode (location: (10,6)-(10,7))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (24...25))
│ │ └── @ IntegerNode (location: (10,6)-(10,7))
│ │ └── flags: decimal
│ ├── keyword_loc: (18...21) = "END"
│ ├── opening_loc: (22...23) = "{"
│ └── closing_loc: (26...27) = "}"
└── @ PreExecutionNode (location: (29...40))
│ ├── keyword_loc: (10,0)-(10,3) = "END"
│ ├── opening_loc: (10,4)-(10,5) = "{"
│ └── closing_loc: (10,8)-(10,9) = "}"
└── @ PreExecutionNode (location: (12,0)-(12,11))
├── statements:
│ @ StatementsNode (location: (37...38))
│ @ StatementsNode (location: (12,8)-(12,9))
│ └── body: (length: 1)
│ └── @ IntegerNode (location: (37...38))
│ └── @ IntegerNode (location: (12,8)-(12,9))
│ └── flags: decimal
├── keyword_loc: (29...34) = "BEGIN"
├── opening_loc: (35...36) = "{"
└── closing_loc: (39...40) = "}"
├── keyword_loc: (12,0)-(12,5) = "BEGIN"
├── opening_loc: (12,6)-(12,7) = "{"
└── 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: []
└── statements:
@ StatementsNode (location: (0...434))
@ StatementsNode (location: (1,0)-(105,3))
└── body: (length: 36)
├── @ DefNode (location: (0...9))
├── @ DefNode (location: (1,0)-(2,3))
│ ├── name: :!
│ ├── name_loc: (4...5) = "!"
│ ├── name_loc: (1,4)-(1,5) = "!"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (0...3) = "def"
│ ├── def_keyword_loc: (1,0)-(1,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (6...9) = "end"
├── @ DefNode (location: (11...21))
│ └── end_keyword_loc: (2,0)-(2,3) = "end"
├── @ DefNode (location: (4,0)-(5,3))
│ ├── name: :!=
│ ├── name_loc: (15...17) = "!="
│ ├── name_loc: (4,4)-(4,6) = "!="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (11...14) = "def"
│ ├── def_keyword_loc: (4,0)-(4,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (18...21) = "end"
├── @ DefNode (location: (23...33))
│ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ DefNode (location: (7,0)-(8,3))
│ ├── name: :!~
│ ├── name_loc: (27...29) = "!~"
│ ├── name_loc: (7,4)-(7,6) = "!~"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (23...26) = "def"
│ ├── def_keyword_loc: (7,0)-(7,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (30...33) = "end"
├── @ DefNode (location: (35...44))
│ └── end_keyword_loc: (8,0)-(8,3) = "end"
├── @ DefNode (location: (10,0)-(11,3))
│ ├── name: :%
│ ├── name_loc: (39...40) = "%"
│ ├── name_loc: (10,4)-(10,5) = "%"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (35...38) = "def"
│ ├── def_keyword_loc: (10,0)-(10,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (41...44) = "end"
├── @ DefNode (location: (46...60))
│ └── end_keyword_loc: (11,0)-(11,3) = "end"
├── @ DefNode (location: (13,0)-(14,3))
│ ├── name: :+
│ ├── name_loc: (55...56) = "+"
│ ├── name_loc: (13,9)-(13,10) = "+"
│ ├── receiver:
│ │ @ SelfNode (location: (50...54))
│ │ @ SelfNode (location: (13,4)-(13,8))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (46...49) = "def"
│ ├── operator_loc: (54...55) = "."
│ ├── def_keyword_loc: (13,0)-(13,3) = "def"
│ ├── operator_loc: (13,8)-(13,9) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (57...60) = "end"
├── @ DefNode (location: (62...71))
│ └── end_keyword_loc: (14,0)-(14,3) = "end"
├── @ DefNode (location: (16,0)-(17,3))
│ ├── name: :&
│ ├── name_loc: (66...67) = "&"
│ ├── name_loc: (16,4)-(16,5) = "&"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (62...65) = "def"
│ ├── def_keyword_loc: (16,0)-(16,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (68...71) = "end"
├── @ DefNode (location: (73...82))
│ └── end_keyword_loc: (17,0)-(17,3) = "end"
├── @ DefNode (location: (19,0)-(20,3))
│ ├── name: :*
│ ├── name_loc: (77...78) = "*"
│ ├── name_loc: (19,4)-(19,5) = "*"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (73...76) = "def"
│ ├── def_keyword_loc: (19,0)-(19,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (79...82) = "end"
├── @ DefNode (location: (84...94))
│ └── end_keyword_loc: (20,0)-(20,3) = "end"
├── @ DefNode (location: (22,0)-(23,3))
│ ├── name: :**
│ ├── name_loc: (88...90) = "**"
│ ├── name_loc: (22,4)-(22,6) = "**"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (84...87) = "def"
│ ├── def_keyword_loc: (22,0)-(22,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (91...94) = "end"
├── @ StringNode (location: (96...102))
│ └── end_keyword_loc: (23,0)-(23,3) = "end"
├── @ StringNode (location: (25,0)-(25,6))
│ ├── flags: ∅
│ ├── opening_loc: (96...98) = "%|"
│ ├── content_loc: (98...101) = "abc"
│ ├── closing_loc: (101...102) = "|"
│ ├── opening_loc: (25,0)-(25,2) = "%|"
│ ├── content_loc: (25,2)-(25,5) = "abc"
│ ├── closing_loc: (25,5)-(25,6) = "|"
│ └── unescaped: "abc"
├── @ DefNode (location: (104...117))
├── @ DefNode (location: (27,0)-(28,3))
│ ├── name: :+
│ ├── name_loc: (108...109) = "+"
│ ├── name_loc: (27,4)-(27,5) = "+"
│ ├── receiver: ∅
│ ├── parameters:
│ │ @ ParametersNode (location: (110...113))
│ │ @ ParametersNode (location: (27,6)-(27,9))
│ │ ├── requireds: (length: 0)
│ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅
│ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest:
│ │ │ @ KeywordRestParameterNode (location: (110...113))
│ │ │ @ KeywordRestParameterNode (location: (27,6)-(27,9))
│ │ │ ├── name: :b
│ │ │ ├── name_loc: (112...113) = "b"
│ │ │ └── operator_loc: (110...112) = "**"
│ │ │ ├── name_loc: (27,8)-(27,9) = "b"
│ │ │ └── operator_loc: (27,6)-(27,8) = "**"
│ │ └── block: ∅
│ ├── body: ∅
│ ├── locals: [:b]
│ ├── def_keyword_loc: (104...107) = "def"
│ ├── def_keyword_loc: (27,0)-(27,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (114...117) = "end"
├── @ DefNode (location: (119...130))
│ └── end_keyword_loc: (28,0)-(28,3) = "end"
├── @ DefNode (location: (30,0)-(31,3))
│ ├── name: :+
│ ├── name_loc: (123...124) = "+"
│ ├── name_loc: (30,4)-(30,5) = "+"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (119...122) = "def"
│ ├── def_keyword_loc: (30,0)-(30,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: (124...125) = "("
│ ├── rparen_loc: (125...126) = ")"
│ ├── lparen_loc: (30,5)-(30,6) = "("
│ ├── rparen_loc: (30,6)-(30,7) = ")"
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (127...130) = "end"
├── @ DefNode (location: (132...143))
│ └── end_keyword_loc: (31,0)-(31,3) = "end"
├── @ DefNode (location: (33,0)-(34,3))
│ ├── name: :+
│ ├── name_loc: (136...137) = "+"
│ ├── name_loc: (33,4)-(33,5) = "+"
│ ├── receiver: ∅
│ ├── parameters:
│ │ @ ParametersNode (location: (138...139))
│ │ @ ParametersNode (location: (33,6)-(33,7))
│ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredParameterNode (location: (138...139))
│ │ │ └── @ RequiredParameterNode (location: (33,6)-(33,7))
│ │ │ └── name: :b
│ │ ├── optionals: (length: 0)
│ │ ├── rest: ∅
@ -169,73 +169,73 @@
│ │ └── block: ∅
│ ├── body: ∅
│ ├── locals: [:b]
│ ├── def_keyword_loc: (132...135) = "def"
│ ├── def_keyword_loc: (33,0)-(33,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (140...143) = "end"
├── @ DefNode (location: (145...159))
│ └── end_keyword_loc: (34,0)-(34,3) = "end"
├── @ DefNode (location: (36,0)-(37,3))
│ ├── name: :+
│ ├── name_loc: (154...155) = "+"
│ ├── name_loc: (36,9)-(36,10) = "+"
│ ├── receiver:
│ │ @ SelfNode (location: (149...153))
│ │ @ SelfNode (location: (36,4)-(36,8))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (145...148) = "def"
│ ├── operator_loc: (153...154) = "."
│ ├── def_keyword_loc: (36,0)-(36,3) = "def"
│ ├── operator_loc: (36,8)-(36,9) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (156...159) = "end"
├── @ DefNode (location: (161...170))
│ └── end_keyword_loc: (37,0)-(37,3) = "end"
├── @ DefNode (location: (39,0)-(40,3))
│ ├── name: :+
│ ├── name_loc: (165...166) = "+"
│ ├── name_loc: (39,4)-(39,5) = "+"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (161...164) = "def"
│ ├── def_keyword_loc: (39,0)-(39,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (167...170) = "end"
├── @ DefNode (location: (172...182))
│ └── end_keyword_loc: (40,0)-(40,3) = "end"
├── @ DefNode (location: (42,0)-(43,3))
│ ├── name: :+@
│ ├── name_loc: (176...178) = "+@"
│ ├── name_loc: (42,4)-(42,6) = "+@"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (172...175) = "def"
│ ├── def_keyword_loc: (42,0)-(42,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (179...182) = "end"
├── @ DefNode (location: (184...193))
│ └── end_keyword_loc: (43,0)-(43,3) = "end"
├── @ DefNode (location: (45,0)-(46,3))
│ ├── name: :-
│ ├── name_loc: (188...189) = "-"
│ ├── name_loc: (45,4)-(45,5) = "-"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (184...187) = "def"
│ ├── def_keyword_loc: (45,0)-(45,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (190...193) = "end"
├── @ DefNode (location: (195...206))
│ └── end_keyword_loc: (46,0)-(46,3) = "end"
├── @ DefNode (location: (48,0)-(48,11))
│ ├── name: :-
│ ├── name_loc: (201...202) = "-"
│ ├── name_loc: (48,6)-(48,7) = "-"
│ ├── receiver:
│ │ @ CallNode (location: (199...200))
│ │ @ CallNode (location: (48,4)-(48,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (199...200) = "a"
│ │ ├── message_loc: (48,4)-(48,5) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -245,257 +245,257 @@
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (195...198) = "def"
│ ├── operator_loc: (200...201) = "."
│ ├── def_keyword_loc: (48,0)-(48,3) = "def"
│ ├── operator_loc: (48,5)-(48,6) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (203...206) = "end"
├── @ DefNode (location: (208...218))
│ └── end_keyword_loc: (48,8)-(48,11) = "end"
├── @ DefNode (location: (50,0)-(51,3))
│ ├── name: :-@
│ ├── name_loc: (212...214) = "-@"
│ ├── name_loc: (50,4)-(50,6) = "-@"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (208...211) = "def"
│ ├── def_keyword_loc: (50,0)-(50,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (215...218) = "end"
├── @ DefNode (location: (220...229))
│ └── end_keyword_loc: (51,0)-(51,3) = "end"
├── @ DefNode (location: (53,0)-(54,3))
│ ├── name: :/
│ ├── name_loc: (224...225) = "/"
│ ├── name_loc: (53,4)-(53,5) = "/"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (220...223) = "def"
│ ├── def_keyword_loc: (53,0)-(53,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (226...229) = "end"
├── @ DefNode (location: (231...240))
│ └── end_keyword_loc: (54,0)-(54,3) = "end"
├── @ DefNode (location: (56,0)-(57,3))
│ ├── name: :<
│ ├── name_loc: (235...236) = "<"
│ ├── name_loc: (56,4)-(56,5) = "<"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (231...234) = "def"
│ ├── def_keyword_loc: (56,0)-(56,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (237...240) = "end"
├── @ DefNode (location: (242...252))
│ └── end_keyword_loc: (57,0)-(57,3) = "end"
├── @ DefNode (location: (59,0)-(60,3))
│ ├── name: :<<
│ ├── name_loc: (246...248) = "<<"
│ ├── name_loc: (59,4)-(59,6) = "<<"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (242...245) = "def"
│ ├── def_keyword_loc: (59,0)-(59,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (249...252) = "end"
├── @ DefNode (location: (254...264))
│ └── end_keyword_loc: (60,0)-(60,3) = "end"
├── @ DefNode (location: (62,0)-(63,3))
│ ├── name: :<=
│ ├── name_loc: (258...260) = "<="
│ ├── name_loc: (62,4)-(62,6) = "<="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (254...257) = "def"
│ ├── def_keyword_loc: (62,0)-(62,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (261...264) = "end"
├── @ DefNode (location: (266...277))
│ └── end_keyword_loc: (63,0)-(63,3) = "end"
├── @ DefNode (location: (65,0)-(66,3))
│ ├── name: :<=>
│ ├── name_loc: (270...273) = "<=>"
│ ├── name_loc: (65,4)-(65,7) = "<=>"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (266...269) = "def"
│ ├── def_keyword_loc: (65,0)-(65,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (274...277) = "end"
├── @ DefNode (location: (279...289))
│ └── end_keyword_loc: (66,0)-(66,3) = "end"
├── @ DefNode (location: (68,0)-(69,3))
│ ├── name: :==
│ ├── name_loc: (283...285) = "=="
│ ├── name_loc: (68,4)-(68,6) = "=="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (279...282) = "def"
│ ├── def_keyword_loc: (68,0)-(68,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (286...289) = "end"
├── @ DefNode (location: (291...302))
│ └── end_keyword_loc: (69,0)-(69,3) = "end"
├── @ DefNode (location: (71,0)-(72,3))
│ ├── name: :===
│ ├── name_loc: (295...298) = "==="
│ ├── name_loc: (71,4)-(71,7) = "==="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (291...294) = "def"
│ ├── def_keyword_loc: (71,0)-(71,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (299...302) = "end"
├── @ DefNode (location: (304...314))
│ └── end_keyword_loc: (72,0)-(72,3) = "end"
├── @ DefNode (location: (74,0)-(75,3))
│ ├── name: :=~
│ ├── name_loc: (308...310) = "=~"
│ ├── name_loc: (74,4)-(74,6) = "=~"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (304...307) = "def"
│ ├── def_keyword_loc: (74,0)-(74,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (311...314) = "end"
├── @ DefNode (location: (316...325))
│ └── end_keyword_loc: (75,0)-(75,3) = "end"
├── @ DefNode (location: (77,0)-(78,3))
│ ├── name: :>
│ ├── name_loc: (320...321) = ">"
│ ├── name_loc: (77,4)-(77,5) = ">"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (316...319) = "def"
│ ├── def_keyword_loc: (77,0)-(77,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (322...325) = "end"
├── @ DefNode (location: (327...337))
│ └── end_keyword_loc: (78,0)-(78,3) = "end"
├── @ DefNode (location: (80,0)-(81,3))
│ ├── name: :>=
│ ├── name_loc: (331...333) = ">="
│ ├── name_loc: (80,4)-(80,6) = ">="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (327...330) = "def"
│ ├── def_keyword_loc: (80,0)-(80,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (334...337) = "end"
├── @ DefNode (location: (339...349))
│ └── end_keyword_loc: (81,0)-(81,3) = "end"
├── @ DefNode (location: (83,0)-(84,3))
│ ├── name: :>>
│ ├── name_loc: (343...345) = ">>"
│ ├── name_loc: (83,4)-(83,6) = ">>"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (339...342) = "def"
│ ├── def_keyword_loc: (83,0)-(83,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (346...349) = "end"
├── @ DefNode (location: (351...361))
│ └── end_keyword_loc: (84,0)-(84,3) = "end"
├── @ DefNode (location: (86,0)-(87,3))
│ ├── name: :[]
│ ├── name_loc: (355...357) = "[]"
│ ├── name_loc: (86,4)-(86,6) = "[]"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (351...354) = "def"
│ ├── def_keyword_loc: (86,0)-(86,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (358...361) = "end"
├── @ DefNode (location: (363...374))
│ └── end_keyword_loc: (87,0)-(87,3) = "end"
├── @ DefNode (location: (89,0)-(90,3))
│ ├── name: :[]=
│ ├── name_loc: (367...370) = "[]="
│ ├── name_loc: (89,4)-(89,7) = "[]="
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (363...366) = "def"
│ ├── def_keyword_loc: (89,0)-(89,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (371...374) = "end"
├── @ DefNode (location: (376...385))
│ └── end_keyword_loc: (90,0)-(90,3) = "end"
├── @ DefNode (location: (92,0)-(93,3))
│ ├── name: :^
│ ├── name_loc: (380...381) = "^"
│ ├── name_loc: (92,4)-(92,5) = "^"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (376...379) = "def"
│ ├── def_keyword_loc: (92,0)-(92,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (382...385) = "end"
├── @ DefNode (location: (387...396))
│ └── end_keyword_loc: (93,0)-(93,3) = "end"
├── @ DefNode (location: (95,0)-(96,3))
│ ├── name: :`
│ ├── name_loc: (391...392) = "`"
│ ├── name_loc: (95,4)-(95,5) = "`"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (387...390) = "def"
│ ├── def_keyword_loc: (95,0)-(95,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (393...396) = "end"
├── @ DefNode (location: (398...412))
│ └── end_keyword_loc: (96,0)-(96,3) = "end"
├── @ DefNode (location: (98,0)-(99,3))
│ ├── name: :`
│ ├── name_loc: (407...408) = "`"
│ ├── name_loc: (98,9)-(98,10) = "`"
│ ├── receiver:
│ │ @ SelfNode (location: (402...406))
│ │ @ SelfNode (location: (98,4)-(98,8))
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (398...401) = "def"
│ ├── operator_loc: (406...407) = "."
│ ├── def_keyword_loc: (98,0)-(98,3) = "def"
│ ├── operator_loc: (98,8)-(98,9) = "."
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (409...412) = "end"
├── @ DefNode (location: (414...423))
│ └── end_keyword_loc: (99,0)-(99,3) = "end"
├── @ DefNode (location: (101,0)-(102,3))
│ ├── name: :|
│ ├── name_loc: (418...419) = "|"
│ ├── name_loc: (101,4)-(101,5) = "|"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── locals: []
│ ├── def_keyword_loc: (414...417) = "def"
│ ├── def_keyword_loc: (101,0)-(101,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: ∅
│ └── end_keyword_loc: (420...423) = "end"
└── @ DefNode (location: (425...434))
│ └── end_keyword_loc: (102,0)-(102,3) = "end"
└── @ DefNode (location: (104,0)-(105,3))
├── name: :~
├── name_loc: (429...430) = "~"
├── name_loc: (104,4)-(104,5) = "~"
├── receiver: ∅
├── parameters: ∅
├── body: ∅
├── locals: []
├── def_keyword_loc: (425...428) = "def"
├── def_keyword_loc: (104,0)-(104,3) = "def"
├── operator_loc: ∅
├── lparen_loc: ∅
├── rparen_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: []
└── statements:
@ StatementsNode (location: (0...190))
@ StatementsNode (location: (1,0)-(37,16))
└── body: (length: 10)
├── @ AndNode (location: (0...19))
├── @ AndNode (location: (1,0)-(1,19))
│ ├── left:
│ │ @ CallNode (location: (0...7))
│ │ @ CallNode (location: (1,0)-(1,7))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (4...7))
│ │ │ @ CallNode (location: (1,4)-(1,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (4...7) = "foo"
│ │ │ ├── message_loc: (1,4)-(1,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -18,7 +18,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "not"
│ │ ├── message_loc: (1,0)-(1,3) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -26,12 +26,12 @@
│ │ ├── flags: ∅
│ │ └── name: "!"
│ ├── right:
│ │ @ CallNode (location: (12...19))
│ │ @ CallNode (location: (1,12)-(1,19))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (16...19))
│ │ │ @ CallNode (location: (1,16)-(1,19))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (16...19) = "bar"
│ │ │ ├── message_loc: (1,16)-(1,19) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -39,22 +39,22 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (12...15) = "not"
│ │ ├── message_loc: (1,12)-(1,15) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "!"
│ └── operator_loc: (8...11) = "and"
├── @ CallNode (location: (21...37))
│ └── operator_loc: (1,8)-(1,11) = "and"
├── @ CallNode (location: (3,0)-(3,16))
│ ├── receiver:
│ │ @ AndNode (location: (25...36))
│ │ @ AndNode (location: (3,4)-(3,15))
│ │ ├── left:
│ │ │ @ CallNode (location: (25...28))
│ │ │ @ CallNode (location: (3,4)-(3,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (25...28) = "foo"
│ │ │ ├── message_loc: (3,4)-(3,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -62,31 +62,31 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── right:
│ │ │ @ CallNode (location: (33...36))
│ │ │ @ CallNode (location: (3,12)-(3,15))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (33...36) = "bar"
│ │ │ ├── message_loc: (3,12)-(3,15) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ └── operator_loc: (29...32) = "and"
│ │ └── operator_loc: (3,8)-(3,11) = "and"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (21...24) = "not"
│ ├── opening_loc: (24...25) = "("
│ ├── message_loc: (3,0)-(3,3) = "not"
│ ├── opening_loc: (3,3)-(3,4) = "("
│ ├── arguments: ∅
│ ├── closing_loc: (36...37) = ")"
│ ├── closing_loc: (3,15)-(3,16) = ")"
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
├── @ CallNode (location: (39...46))
├── @ CallNode (location: (5,0)-(5,7))
│ ├── receiver:
│ │ @ CallNode (location: (43...46))
│ │ @ CallNode (location: (5,4)-(5,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (43...46) = "foo"
│ │ ├── message_loc: (5,4)-(5,7) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -94,21 +94,21 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (39...42) = "not"
│ ├── message_loc: (5,0)-(5,3) = "not"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
├── @ AndNode (location: (48...69))
├── @ AndNode (location: (7,0)-(8,5))
│ ├── left:
│ │ @ CallNode (location: (48...55))
│ │ @ CallNode (location: (7,0)-(7,7))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (52...55))
│ │ │ @ CallNode (location: (7,4)-(7,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (52...55) = "foo"
│ │ │ ├── message_loc: (7,4)-(7,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -116,7 +116,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (48...51) = "not"
│ │ ├── message_loc: (7,0)-(7,3) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -124,12 +124,12 @@
│ │ ├── flags: ∅
│ │ └── name: "!"
│ ├── right:
│ │ @ CallNode (location: (60...69))
│ │ @ CallNode (location: (7,12)-(8,5))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (66...69))
│ │ │ @ CallNode (location: (8,2)-(8,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (66...69) = "bar"
│ │ │ ├── message_loc: (8,2)-(8,5) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -137,22 +137,22 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (60...63) = "not"
│ │ ├── message_loc: (7,12)-(7,15) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "!"
│ └── operator_loc: (56...59) = "and"
├── @ AndNode (location: (72...97))
│ └── operator_loc: (7,8)-(7,11) = "and"
├── @ AndNode (location: (11,0)-(13,5))
│ ├── left:
│ │ @ CallNode (location: (72...79))
│ │ @ CallNode (location: (11,0)-(11,7))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (76...79))
│ │ │ @ CallNode (location: (11,4)-(11,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (76...79) = "foo"
│ │ │ ├── message_loc: (11,4)-(11,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -160,7 +160,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (72...75) = "not"
│ │ ├── message_loc: (11,0)-(11,3) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -168,12 +168,12 @@
│ │ ├── flags: ∅
│ │ └── name: "!"
│ ├── right:
│ │ @ CallNode (location: (88...97))
│ │ @ CallNode (location: (12,4)-(13,5))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (94...97))
│ │ │ @ CallNode (location: (13,2)-(13,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (94...97) = "bar"
│ │ │ ├── message_loc: (13,2)-(13,5) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -181,22 +181,22 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (88...91) = "not"
│ │ ├── message_loc: (12,4)-(12,7) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "!"
│ └── operator_loc: (80...83) = "and"
├── @ AndNode (location: (100...125))
│ └── operator_loc: (11,8)-(11,11) = "and"
├── @ AndNode (location: (16,0)-(20,5))
│ ├── left:
│ │ @ CallNode (location: (100...107))
│ │ @ CallNode (location: (16,0)-(16,7))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (104...107))
│ │ │ @ CallNode (location: (16,4)-(16,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (104...107) = "foo"
│ │ │ ├── message_loc: (16,4)-(16,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -204,7 +204,7 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (100...103) = "not"
│ │ ├── message_loc: (16,0)-(16,3) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -212,12 +212,12 @@
│ │ ├── flags: ∅
│ │ └── name: "!"
│ ├── right:
│ │ @ CallNode (location: (114...125))
│ │ @ CallNode (location: (17,2)-(20,5))
│ │ ├── receiver:
│ │ │ @ CallNode (location: (122...125))
│ │ │ @ CallNode (location: (20,2)-(20,5))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (122...125) = "bar"
│ │ │ ├── message_loc: (20,2)-(20,5) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -225,20 +225,20 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (114...117) = "not"
│ │ ├── message_loc: (17,2)-(17,5) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "!"
│ └── operator_loc: (108...111) = "and"
├── @ CallNode (location: (127...138))
│ └── operator_loc: (16,8)-(16,11) = "and"
├── @ CallNode (location: (22,0)-(25,1))
│ ├── receiver:
│ │ @ CallNode (location: (131...134))
│ │ @ CallNode (location: (22,4)-(22,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (131...134) = "foo"
│ │ ├── message_loc: (22,4)-(22,7) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -246,19 +246,19 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (127...130) = "not"
│ ├── opening_loc: (130...131) = "("
│ ├── message_loc: (22,0)-(22,3) = "not"
│ ├── opening_loc: (22,3)-(22,4) = "("
│ ├── arguments: ∅
│ ├── closing_loc: (137...138) = ")"
│ ├── closing_loc: (25,0)-(25,1) = ")"
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
├── @ CallNode (location: (140...156))
├── @ CallNode (location: (27,0)-(33,3))
│ ├── receiver:
│ │ @ CallNode (location: (147...150))
│ │ @ CallNode (location: (30,0)-(30,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (147...150) = "foo"
│ │ ├── message_loc: (30,0)-(30,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -266,21 +266,21 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (140...143) = "not"
│ ├── opening_loc: (143...144) = "("
│ ├── message_loc: (27,0)-(27,3) = "not"
│ ├── opening_loc: (27,3)-(27,4) = "("
│ ├── arguments: ∅
│ ├── closing_loc: (155...156) = ")"
│ ├── closing_loc: (33,2)-(33,3) = ")"
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
├── @ CallNode (location: (158...172))
├── @ CallNode (location: (35,0)-(35,14))
│ ├── receiver:
│ │ @ FlipFlopNode (location: (162...172))
│ │ @ FlipFlopNode (location: (35,4)-(35,14))
│ │ ├── left:
│ │ │ @ CallNode (location: (162...165))
│ │ │ @ CallNode (location: (35,4)-(35,7))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (162...165) = "foo"
│ │ │ ├── message_loc: (35,4)-(35,7) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -288,38 +288,38 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── right:
│ │ │ @ CallNode (location: (169...172))
│ │ │ @ CallNode (location: (35,11)-(35,14))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (169...172) = "bar"
│ │ │ ├── message_loc: (35,11)-(35,14) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── operator_loc: (166...168) = ".."
│ │ ├── operator_loc: (35,8)-(35,10) = ".."
│ │ └── flags: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (158...161) = "not"
│ ├── message_loc: (35,0)-(35,3) = "not"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "!"
└── @ CallNode (location: (174...190))
└── @ CallNode (location: (37,0)-(37,16))
├── receiver:
│ @ ParenthesesNode (location: (178...190))
│ @ ParenthesesNode (location: (37,4)-(37,16))
│ ├── body:
│ │ @ StatementsNode (location: (179...189))
│ │ @ StatementsNode (location: (37,5)-(37,15))
│ │ └── body: (length: 1)
│ │ └── @ FlipFlopNode (location: (179...189))
│ │ └── @ FlipFlopNode (location: (37,5)-(37,15))
│ │ ├── left:
│ │ │ @ CallNode (location: (179...182))
│ │ │ @ CallNode (location: (37,5)-(37,8))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (179...182) = "foo"
│ │ │ ├── message_loc: (37,5)-(37,8) = "foo"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -327,22 +327,22 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "foo"
│ │ ├── right:
│ │ │ @ CallNode (location: (186...189))
│ │ │ @ CallNode (location: (37,12)-(37,15))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (186...189) = "bar"
│ │ │ ├── message_loc: (37,12)-(37,15) = "bar"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "bar"
│ │ ├── operator_loc: (183...185) = ".."
│ │ ├── operator_loc: (37,9)-(37,11) = ".."
│ │ └── flags: ∅
│ ├── opening_loc: (178...179) = "("
│ └── closing_loc: (189...190) = ")"
│ ├── opening_loc: (37,4)-(37,5) = "("
│ └── closing_loc: (37,15)-(37,16) = ")"
├── call_operator_loc: ∅
├── message_loc: (174...177) = "not"
├── message_loc: (37,0)-(37,3) = "not"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...161))
@ StatementsNode (location: (1,0)-(63,5))
└── body: (length: 32)
├── @ IntegerNode (location: (0...1))
├── @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal
├── @ IntegerNode (location: (3...4))
├── @ IntegerNode (location: (3,0)-(3,1))
│ └── flags: decimal
├── @ FloatNode (location: (6...9))
├── @ IntegerNode (location: (11...12))
├── @ FloatNode (location: (5,0)-(5,3))
├── @ IntegerNode (location: (7,0)-(7,1))
│ └── flags: decimal
├── @ IntegerNode (location: (14...17))
├── @ IntegerNode (location: (9,0)-(9,3))
│ └── flags: binary
├── @ IntegerNode (location: (19...22))
├── @ IntegerNode (location: (11,0)-(11,3))
│ └── flags: binary
├── @ IntegerNode (location: (24...28))
├── @ IntegerNode (location: (13,0)-(13,4))
│ └── flags: binary
├── @ IntegerNode (location: (30...33))
├── @ IntegerNode (location: (15,0)-(15,3))
│ └── flags: decimal
├── @ IntegerNode (location: (35...38))
├── @ IntegerNode (location: (17,0)-(17,3))
│ └── flags: decimal
├── @ IntegerNode (location: (40...43))
├── @ IntegerNode (location: (19,0)-(19,3))
│ └── flags: decimal
├── @ IntegerNode (location: (45...47))
├── @ IntegerNode (location: (21,0)-(21,2))
│ └── flags: octal
├── @ IntegerNode (location: (49...51))
├── @ IntegerNode (location: (23,0)-(23,2))
│ └── flags: octal
├── @ IntegerNode (location: (53...55))
├── @ IntegerNode (location: (25,0)-(25,2))
│ └── flags: octal
├── @ IntegerNode (location: (57...60))
├── @ IntegerNode (location: (27,0)-(27,3))
│ └── flags: octal
├── @ IntegerNode (location: (62...65))
├── @ IntegerNode (location: (29,0)-(29,3))
│ └── flags: octal
├── @ IntegerNode (location: (67...70))
├── @ IntegerNode (location: (31,0)-(31,3))
│ └── flags: octal
├── @ IntegerNode (location: (72...75))
├── @ IntegerNode (location: (33,0)-(33,3))
│ └── flags: hexadecimal
├── @ IntegerNode (location: (77...80))
├── @ IntegerNode (location: (35,0)-(35,3))
│ └── flags: hexadecimal
├── @ IntegerNode (location: (82...85))
├── @ IntegerNode (location: (37,0)-(37,3))
│ └── flags: hexadecimal
├── @ ImaginaryNode (location: (87...89))
├── @ ImaginaryNode (location: (39,0)-(39,2))
│ └── numeric:
│ @ IntegerNode (location: (87...88))
│ @ IntegerNode (location: (39,0)-(39,1))
│ └── flags: decimal
├── @ RationalNode (location: (91...93))
├── @ RationalNode (location: (41,0)-(41,2))
│ └── numeric:
│ @ IntegerNode (location: (91...92))
│ @ IntegerNode (location: (41,0)-(41,1))
│ └── flags: decimal
├── @ IntegerNode (location: (95...97))
├── @ IntegerNode (location: (43,0)-(43,2))
│ └── flags: decimal
├── @ ImaginaryNode (location: (99...102))
├── @ ImaginaryNode (location: (45,0)-(45,3))
│ └── numeric:
│ @ RationalNode (location: (99...101))
│ @ RationalNode (location: (45,0)-(45,2))
│ └── numeric:
│ @ IntegerNode (location: (99...100))
│ @ IntegerNode (location: (45,0)-(45,1))
│ └── flags: decimal
├── @ ImaginaryNode (location: (104...109))
├── @ ImaginaryNode (location: (47,0)-(47,5))
│ └── numeric:
│ @ RationalNode (location: (104...108))
│ @ RationalNode (location: (47,0)-(47,4))
│ └── numeric:
│ @ FloatNode (location: (104...107))
├── @ ImaginaryNode (location: (111...115))
│ @ FloatNode (location: (47,0)-(47,3))
├── @ ImaginaryNode (location: (49,0)-(49,4))
│ └── numeric:
│ @ RationalNode (location: (111...114))
│ @ RationalNode (location: (49,0)-(49,3))
│ └── numeric:
│ @ IntegerNode (location: (111...113))
│ @ IntegerNode (location: (49,0)-(49,2))
│ └── flags: decimal
├── @ ImaginaryNode (location: (117...123))
├── @ ImaginaryNode (location: (51,0)-(51,6))
│ └── numeric:
│ @ RationalNode (location: (117...122))
│ @ RationalNode (location: (51,0)-(51,5))
│ └── numeric:
│ @ FloatNode (location: (117...121))
├── @ RationalNode (location: (125...129))
│ @ FloatNode (location: (51,0)-(51,4))
├── @ RationalNode (location: (53,0)-(53,4))
│ └── numeric:
│ @ IntegerNode (location: (125...128))
│ @ IntegerNode (location: (53,0)-(53,3))
│ └── flags: octal
├── @ ImaginaryNode (location: (131...135))
├── @ ImaginaryNode (location: (55,0)-(55,4))
│ └── numeric:
│ @ IntegerNode (location: (131...134))
│ @ IntegerNode (location: (55,0)-(55,3))
│ └── flags: octal
├── @ ImaginaryNode (location: (137...142))
├── @ ImaginaryNode (location: (57,0)-(57,5))
│ └── numeric:
│ @ RationalNode (location: (137...141))
│ @ RationalNode (location: (57,0)-(57,4))
│ └── numeric:
│ @ IntegerNode (location: (137...140))
│ @ IntegerNode (location: (57,0)-(57,3))
│ └── flags: octal
├── @ RationalNode (location: (144...148))
├── @ RationalNode (location: (59,0)-(59,4))
│ └── numeric:
│ @ IntegerNode (location: (144...147))
│ @ IntegerNode (location: (59,0)-(59,3))
│ └── flags: decimal
├── @ ImaginaryNode (location: (150...154))
├── @ ImaginaryNode (location: (61,0)-(61,4))
│ └── numeric:
│ @ IntegerNode (location: (150...153))
│ @ IntegerNode (location: (61,0)-(61,3))
│ └── flags: decimal
└── @ ImaginaryNode (location: (156...161))
└── @ ImaginaryNode (location: (63,0)-(63,5))
└── numeric:
@ RationalNode (location: (156...160))
@ RationalNode (location: (63,0)-(63,4))
└── numeric:
@ IntegerNode (location: (156...159))
@ IntegerNode (location: (63,0)-(63,3))
└── 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: []
└── statements:
@ StatementsNode (location: (0...266))
@ StatementsNode (location: (1,0)-(27,19))
└── body: (length: 10)
├── @ LambdaNode (location: (0...21))
├── @ LambdaNode (location: (1,0)-(1,21))
│ ├── locals: [:a, :b, :c, :d]
│ ├── operator_loc: (0...2) = "->"
│ ├── opening_loc: (16...17) = "{"
│ ├── closing_loc: (20...21) = "}"
│ ├── operator_loc: (1,0)-(1,2) = "->"
│ ├── opening_loc: (1,16)-(1,17) = "{"
│ ├── closing_loc: (1,20)-(1,21) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (3...15))
│ │ @ BlockParametersNode (location: (1,3)-(1,15))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (4...5))
│ │ │ @ ParametersNode (location: (1,4)-(1,5))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (4...5))
│ │ │ │ └── @ RequiredParameterNode (location: (1,4)-(1,5))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -22,270 +22,270 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 3)
│ │ │ ├── @ BlockLocalVariableNode (location: (7...8))
│ │ │ ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
│ │ │ │ └── name: :b
│ │ │ ├── @ BlockLocalVariableNode (location: (10...11))
│ │ │ ├── @ BlockLocalVariableNode (location: (1,10)-(1,11))
│ │ │ │ └── name: :c
│ │ │ └── @ BlockLocalVariableNode (location: (13...14))
│ │ │ └── @ BlockLocalVariableNode (location: (1,13)-(1,14))
│ │ │ └── name: :d
│ │ ├── opening_loc: (3...4) = "("
│ │ └── closing_loc: (14...15) = ")"
│ │ ├── opening_loc: (1,3)-(1,4) = "("
│ │ └── closing_loc: (1,14)-(1,15) = ")"
│ └── body:
│ @ StatementsNode (location: (18...19))
│ @ StatementsNode (location: (1,18)-(1,19))
│ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (18...19))
│ └── @ LocalVariableReadNode (location: (1,18)-(1,19))
│ ├── name: :b
│ └── depth: 0
├── @ LambdaNode (location: (23...39))
├── @ LambdaNode (location: (3,0)-(5,3))
│ ├── locals: []
│ ├── operator_loc: (23...25) = "->"
│ ├── opening_loc: (26...28) = "do"
│ ├── closing_loc: (36...39) = "end"
│ ├── operator_loc: (3,0)-(3,2) = "->"
│ ├── opening_loc: (3,3)-(3,5) = "do"
│ ├── closing_loc: (5,0)-(5,3) = "end"
│ ├── parameters: ∅
│ └── body:
│ @ BeginNode (location: (29...39))
│ @ BeginNode (location: (4,0)-(5,3))
│ ├── begin_keyword_loc: ∅
│ ├── statements: ∅
│ ├── rescue_clause: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (29...39))
│ │ ├── ensure_keyword_loc: (29...35) = "ensure"
│ │ @ EnsureNode (location: (4,0)-(5,3))
│ │ ├── ensure_keyword_loc: (4,0)-(4,6) = "ensure"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (36...39) = "end"
│ └── end_keyword_loc: (36...39) = "end"
├── @ LambdaNode (location: (41...69))
│ │ └── end_keyword_loc: (5,0)-(5,3) = "end"
│ └── end_keyword_loc: (5,0)-(5,3) = "end"
├── @ LambdaNode (location: (7,0)-(11,3))
│ ├── locals: []
│ ├── operator_loc: (41...43) = "->"
│ ├── opening_loc: (44...46) = "do"
│ ├── closing_loc: (66...69) = "end"
│ ├── operator_loc: (7,0)-(7,2) = "->"
│ ├── opening_loc: (7,3)-(7,5) = "do"
│ ├── closing_loc: (11,0)-(11,3) = "end"
│ ├── parameters: ∅
│ └── body:
│ @ BeginNode (location: (47...69))
│ @ BeginNode (location: (8,0)-(11,3))
│ ├── begin_keyword_loc: ∅
│ ├── statements: ∅
│ ├── rescue_clause:
│ │ @ RescueNode (location: (47...53))
│ │ ├── keyword_loc: (47...53) = "rescue"
│ │ @ RescueNode (location: (8,0)-(8,6))
│ │ ├── keyword_loc: (8,0)-(8,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
│ │ ├── statements: ∅
│ │ └── consequent: ∅
│ ├── else_clause:
│ │ @ ElseNode (location: (54...65))
│ │ ├── else_keyword_loc: (54...58) = "else"
│ │ @ ElseNode (location: (9,0)-(10,6))
│ │ ├── else_keyword_loc: (9,0)-(9,4) = "else"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (59...65) = "ensure"
│ │ └── end_keyword_loc: (10,0)-(10,6) = "ensure"
│ ├── ensure_clause:
│ │ @ EnsureNode (location: (59...69))
│ │ ├── ensure_keyword_loc: (59...65) = "ensure"
│ │ @ EnsureNode (location: (10,0)-(11,3))
│ │ ├── ensure_keyword_loc: (10,0)-(10,6) = "ensure"
│ │ ├── statements: ∅
│ │ └── end_keyword_loc: (66...69) = "end"
│ └── end_keyword_loc: (66...69) = "end"
├── @ LambdaNode (location: (71...81))
│ │ └── end_keyword_loc: (11,0)-(11,3) = "end"
│ └── end_keyword_loc: (11,0)-(11,3) = "end"
├── @ LambdaNode (location: (13,0)-(13,10))
│ ├── locals: []
│ ├── operator_loc: (71...73) = "->"
│ ├── opening_loc: (74...75) = "{"
│ ├── closing_loc: (80...81) = "}"
│ ├── operator_loc: (13,0)-(13,2) = "->"
│ ├── opening_loc: (13,3)-(13,4) = "{"
│ ├── closing_loc: (13,9)-(13,10) = "}"
│ ├── parameters: ∅
│ └── body:
│ @ StatementsNode (location: (76...79))
│ @ StatementsNode (location: (13,5)-(13,8))
│ └── body: (length: 1)
│ └── @ CallNode (location: (76...79))
│ └── @ CallNode (location: (13,5)-(13,8))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (76...79) = "foo"
│ ├── message_loc: (13,5)-(13,8) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "foo"
├── @ LambdaNode (location: (83...98))
├── @ LambdaNode (location: (15,0)-(15,15))
│ ├── locals: []
│ ├── operator_loc: (83...85) = "->"
│ ├── opening_loc: (86...88) = "do"
│ ├── closing_loc: (95...98) = "end"
│ ├── operator_loc: (15,0)-(15,2) = "->"
│ ├── opening_loc: (15,3)-(15,5) = "do"
│ ├── closing_loc: (15,12)-(15,15) = "end"
│ ├── parameters: ∅
│ └── body:
│ @ StatementsNode (location: (90...93))
│ @ StatementsNode (location: (15,7)-(15,10))
│ └── body: (length: 1)
│ └── @ CallNode (location: (90...93))
│ └── @ CallNode (location: (15,7)-(15,10))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (90...93) = "foo"
│ ├── message_loc: (15,7)-(15,10) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "foo"
├── @ LambdaNode (location: (100...129))
├── @ LambdaNode (location: (17,0)-(17,29))
│ ├── locals: [:a, :b, :c, :d, :e]
│ ├── operator_loc: (100...102) = "->"
│ ├── opening_loc: (124...125) = "{"
│ ├── closing_loc: (128...129) = "}"
│ ├── operator_loc: (17,0)-(17,2) = "->"
│ ├── opening_loc: (17,24)-(17,25) = "{"
│ ├── closing_loc: (17,28)-(17,29) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (103...123))
│ │ @ BlockParametersNode (location: (17,3)-(17,23))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (103...123))
│ │ │ @ ParametersNode (location: (17,3)-(17,23))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (103...104))
│ │ │ │ └── @ RequiredParameterNode (location: (17,3)-(17,4))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (106...111))
│ │ │ │ └── @ OptionalParameterNode (location: (17,6)-(17,11))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (106...107) = "b"
│ │ │ │ ├── operator_loc: (108...109) = "="
│ │ │ │ ├── name_loc: (17,6)-(17,7) = "b"
│ │ │ │ ├── operator_loc: (17,8)-(17,9) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (110...111))
│ │ │ │ @ IntegerNode (location: (17,10)-(17,11))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (113...115))
│ │ │ │ ├── @ KeywordParameterNode (location: (17,13)-(17,15))
│ │ │ │ │ ├── name: :c
│ │ │ │ │ ├── name_loc: (113...115) = "c:"
│ │ │ │ │ ├── name_loc: (17,13)-(17,15) = "c:"
│ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (117...119))
│ │ │ │ └── @ KeywordParameterNode (location: (17,17)-(17,19))
│ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (117...119) = "d:"
│ │ │ │ ├── name_loc: (17,17)-(17,19) = "d:"
│ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (121...123))
│ │ │ @ BlockParameterNode (location: (17,21)-(17,23))
│ │ │ ├── name: :e
│ │ │ ├── name_loc: (122...123) = "e"
│ │ │ └── operator_loc: (121...122) = "&"
│ │ │ ├── name_loc: (17,22)-(17,23) = "e"
│ │ │ └── operator_loc: (17,21)-(17,22) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅
│ └── body:
│ @ StatementsNode (location: (126...127))
│ @ StatementsNode (location: (17,26)-(17,27))
│ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (126...127))
│ └── @ LocalVariableReadNode (location: (17,26)-(17,27))
│ ├── name: :a
│ └── depth: 0
├── @ LambdaNode (location: (131...171))
├── @ LambdaNode (location: (19,0)-(19,40))
│ ├── locals: [:a, :b, :c, :d, :e, :f, :g]
│ ├── operator_loc: (131...133) = "->"
│ ├── opening_loc: (166...167) = "{"
│ ├── closing_loc: (170...171) = "}"
│ ├── operator_loc: (19,0)-(19,2) = "->"
│ ├── opening_loc: (19,35)-(19,36) = "{"
│ ├── closing_loc: (19,39)-(19,40) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (134...165))
│ │ @ BlockParametersNode (location: (19,3)-(19,34))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (135...164))
│ │ │ @ ParametersNode (location: (19,4)-(19,33))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (135...136))
│ │ │ │ └── @ RequiredParameterNode (location: (19,4)-(19,5))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (138...143))
│ │ │ │ └── @ OptionalParameterNode (location: (19,7)-(19,12))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (138...139) = "b"
│ │ │ │ ├── operator_loc: (140...141) = "="
│ │ │ │ ├── name_loc: (19,7)-(19,8) = "b"
│ │ │ │ ├── operator_loc: (19,9)-(19,10) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (142...143))
│ │ │ │ @ IntegerNode (location: (19,11)-(19,12))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (145...147))
│ │ │ │ @ RestParameterNode (location: (19,14)-(19,16))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (146...147) = "c"
│ │ │ │ └── operator_loc: (145...146) = "*"
│ │ │ │ ├── name_loc: (19,15)-(19,16) = "c"
│ │ │ │ └── operator_loc: (19,14)-(19,15) = "*"
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (149...151))
│ │ │ │ ├── @ KeywordParameterNode (location: (19,18)-(19,20))
│ │ │ │ │ ├── name: :d
│ │ │ │ │ ├── name_loc: (149...151) = "d:"
│ │ │ │ │ ├── name_loc: (19,18)-(19,20) = "d:"
│ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (153...155))
│ │ │ │ └── @ KeywordParameterNode (location: (19,22)-(19,24))
│ │ │ │ ├── name: :e
│ │ │ │ ├── name_loc: (153...155) = "e:"
│ │ │ │ ├── name_loc: (19,22)-(19,24) = "e:"
│ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (157...160))
│ │ │ │ @ KeywordRestParameterNode (location: (19,26)-(19,29))
│ │ │ │ ├── name: :f
│ │ │ │ ├── name_loc: (159...160) = "f"
│ │ │ │ └── operator_loc: (157...159) = "**"
│ │ │ │ ├── name_loc: (19,28)-(19,29) = "f"
│ │ │ │ └── operator_loc: (19,26)-(19,28) = "**"
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (162...164))
│ │ │ @ BlockParameterNode (location: (19,31)-(19,33))
│ │ │ ├── name: :g
│ │ │ ├── name_loc: (163...164) = "g"
│ │ │ └── operator_loc: (162...163) = "&"
│ │ │ ├── name_loc: (19,32)-(19,33) = "g"
│ │ │ └── operator_loc: (19,31)-(19,32) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (134...135) = "("
│ │ └── closing_loc: (164...165) = ")"
│ │ ├── opening_loc: (19,3)-(19,4) = "("
│ │ └── closing_loc: (19,33)-(19,34) = ")"
│ └── body:
│ @ StatementsNode (location: (168...169))
│ @ StatementsNode (location: (19,37)-(19,38))
│ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (168...169))
│ └── @ LocalVariableReadNode (location: (19,37)-(19,38))
│ ├── name: :a
│ └── depth: 0
├── @ LambdaNode (location: (173...218))
├── @ LambdaNode (location: (21,0)-(23,3))
│ ├── locals: [:a, :b, :c, :d, :e, :f, :g]
│ ├── operator_loc: (173...175) = "->"
│ ├── opening_loc: (208...210) = "do"
│ ├── closing_loc: (215...218) = "end"
│ ├── operator_loc: (21,0)-(21,2) = "->"
│ ├── opening_loc: (21,35)-(21,37) = "do"
│ ├── closing_loc: (23,0)-(23,3) = "end"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (176...207))
│ │ @ BlockParametersNode (location: (21,3)-(21,34))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (177...206))
│ │ │ @ ParametersNode (location: (21,4)-(21,33))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (177...178))
│ │ │ │ └── @ RequiredParameterNode (location: (21,4)-(21,5))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (180...185))
│ │ │ │ └── @ OptionalParameterNode (location: (21,7)-(21,12))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (180...181) = "b"
│ │ │ │ ├── operator_loc: (182...183) = "="
│ │ │ │ ├── name_loc: (21,7)-(21,8) = "b"
│ │ │ │ ├── operator_loc: (21,9)-(21,10) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (184...185))
│ │ │ │ @ IntegerNode (location: (21,11)-(21,12))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (187...189))
│ │ │ │ @ RestParameterNode (location: (21,14)-(21,16))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (188...189) = "c"
│ │ │ │ └── operator_loc: (187...188) = "*"
│ │ │ │ ├── name_loc: (21,15)-(21,16) = "c"
│ │ │ │ └── operator_loc: (21,14)-(21,15) = "*"
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 2)
│ │ │ │ ├── @ KeywordParameterNode (location: (191...193))
│ │ │ │ ├── @ KeywordParameterNode (location: (21,18)-(21,20))
│ │ │ │ │ ├── name: :d
│ │ │ │ │ ├── name_loc: (191...193) = "d:"
│ │ │ │ │ ├── name_loc: (21,18)-(21,20) = "d:"
│ │ │ │ │ └── value: ∅
│ │ │ │ └── @ KeywordParameterNode (location: (195...197))
│ │ │ │ └── @ KeywordParameterNode (location: (21,22)-(21,24))
│ │ │ │ ├── name: :e
│ │ │ │ ├── name_loc: (195...197) = "e:"
│ │ │ │ ├── name_loc: (21,22)-(21,24) = "e:"
│ │ │ │ └── value: ∅
│ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (199...202))
│ │ │ │ @ KeywordRestParameterNode (location: (21,26)-(21,29))
│ │ │ │ ├── name: :f
│ │ │ │ ├── name_loc: (201...202) = "f"
│ │ │ │ └── operator_loc: (199...201) = "**"
│ │ │ │ ├── name_loc: (21,28)-(21,29) = "f"
│ │ │ │ └── operator_loc: (21,26)-(21,28) = "**"
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (204...206))
│ │ │ @ BlockParameterNode (location: (21,31)-(21,33))
│ │ │ ├── name: :g
│ │ │ ├── name_loc: (205...206) = "g"
│ │ │ └── operator_loc: (204...205) = "&"
│ │ │ ├── name_loc: (21,32)-(21,33) = "g"
│ │ │ └── operator_loc: (21,31)-(21,32) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (176...177) = "("
│ │ └── closing_loc: (206...207) = ")"
│ │ ├── opening_loc: (21,3)-(21,4) = "("
│ │ └── closing_loc: (21,33)-(21,34) = ")"
│ └── body:
│ @ StatementsNode (location: (213...214))
│ @ StatementsNode (location: (22,2)-(22,3))
│ └── body: (length: 1)
│ └── @ LocalVariableReadNode (location: (213...214))
│ └── @ LocalVariableReadNode (location: (22,2)-(22,3))
│ ├── name: :a
│ └── depth: 0
├── @ LambdaNode (location: (220...245))
├── @ LambdaNode (location: (25,0)-(25,25))
│ ├── locals: [:a]
│ ├── operator_loc: (220...222) = "->"
│ ├── opening_loc: (227...228) = "{"
│ ├── closing_loc: (244...245) = "}"
│ ├── operator_loc: (25,0)-(25,2) = "->"
│ ├── opening_loc: (25,7)-(25,8) = "{"
│ ├── closing_loc: (25,24)-(25,25) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (223...226))
│ │ @ BlockParametersNode (location: (25,3)-(25,6))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (224...225))
│ │ │ @ ParametersNode (location: (25,4)-(25,5))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (224...225))
│ │ │ │ └── @ RequiredParameterNode (location: (25,4)-(25,5))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -294,22 +294,22 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (223...224) = "("
│ │ └── closing_loc: (225...226) = ")"
│ │ ├── opening_loc: (25,3)-(25,4) = "("
│ │ └── closing_loc: (25,5)-(25,6) = ")"
│ └── body:
│ @ StatementsNode (location: (229...243))
│ @ StatementsNode (location: (25,9)-(25,23))
│ └── body: (length: 1)
│ └── @ LambdaNode (location: (229...243))
│ └── @ LambdaNode (location: (25,9)-(25,23))
│ ├── locals: [:b]
│ ├── operator_loc: (229...231) = "->"
│ ├── opening_loc: (234...235) = "{"
│ ├── closing_loc: (242...243) = "}"
│ ├── operator_loc: (25,9)-(25,11) = "->"
│ ├── opening_loc: (25,14)-(25,15) = "{"
│ ├── closing_loc: (25,22)-(25,23) = "}"
│ ├── parameters:
│ │ @ BlockParametersNode (location: (232...233))
│ │ @ BlockParametersNode (location: (25,12)-(25,13))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (232...233))
│ │ │ @ ParametersNode (location: (25,12)-(25,13))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (232...233))
│ │ │ │ └── @ RequiredParameterNode (location: (25,12)-(25,13))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -321,55 +321,55 @@
│ │ ├── opening_loc: ∅
│ │ └── closing_loc: ∅
│ └── body:
│ @ StatementsNode (location: (236...241))
│ @ StatementsNode (location: (25,16)-(25,21))
│ └── body: (length: 1)
│ └── @ CallNode (location: (236...241))
│ └── @ CallNode (location: (25,16)-(25,21))
│ ├── receiver:
│ │ @ LocalVariableReadNode (location: (236...237))
│ │ @ LocalVariableReadNode (location: (25,16)-(25,17))
│ │ ├── name: :a
│ │ └── depth: 1
│ ├── call_operator_loc: ∅
│ ├── message_loc: (238...239) = "*"
│ ├── message_loc: (25,18)-(25,19) = "*"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (240...241))
│ │ @ ArgumentsNode (location: (25,20)-(25,21))
│ │ └── arguments: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (240...241))
│ │ └── @ LocalVariableReadNode (location: (25,20)-(25,21))
│ │ ├── name: :b
│ │ └── depth: 0
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "*"
└── @ LambdaNode (location: (247...266))
└── @ LambdaNode (location: (27,0)-(27,19))
├── locals: [:a, :b, :c]
├── operator_loc: (247...249) = "->"
├── opening_loc: (263...264) = "{"
├── closing_loc: (265...266) = "}"
├── operator_loc: (27,0)-(27,2) = "->"
├── opening_loc: (27,16)-(27,17) = "{"
├── closing_loc: (27,18)-(27,19) = "}"
├── parameters:
│ @ BlockParametersNode (location: (250...262))
│ @ BlockParametersNode (location: (27,3)-(27,15))
│ ├── parameters:
│ │ @ ParametersNode (location: (251...261))
│ │ @ ParametersNode (location: (27,4)-(27,14))
│ │ ├── requireds: (length: 1)
│ │ │ └── @ RequiredDestructuredParameterNode (location: (251...257))
│ │ │ └── @ RequiredDestructuredParameterNode (location: (27,4)-(27,10))
│ │ │ ├── parameters: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (252...253))
│ │ │ │ ├── @ RequiredParameterNode (location: (27,5)-(27,6))
│ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (255...256))
│ │ │ │ └── @ RequiredParameterNode (location: (27,8)-(27,9))
│ │ │ │ └── name: :b
│ │ │ ├── opening_loc: (251...252) = "("
│ │ │ └── closing_loc: (256...257) = ")"
│ │ │ ├── opening_loc: (27,4)-(27,5) = "("
│ │ │ └── closing_loc: (27,9)-(27,10) = ")"
│ │ ├── optionals: (length: 0)
│ │ ├── rest:
│ │ │ @ RestParameterNode (location: (259...261))
│ │ │ @ RestParameterNode (location: (27,12)-(27,14))
│ │ │ ├── name: :c
│ │ │ ├── name_loc: (260...261) = "c"
│ │ │ └── operator_loc: (259...260) = "*"
│ │ │ ├── name_loc: (27,13)-(27,14) = "c"
│ │ │ └── operator_loc: (27,12)-(27,13) = "*"
│ │ ├── posts: (length: 0)
│ │ ├── keywords: (length: 0)
│ │ ├── keyword_rest: ∅
│ │ └── block: ∅
│ ├── locals: (length: 0)
│ ├── opening_loc: (250...251) = "("
│ └── closing_loc: (261...262) = ")"
│ ├── opening_loc: (27,3)-(27,4) = "("
│ └── closing_loc: (27,14)-(27,15) = ")"
└── 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: []
└── statements:
@ StatementsNode (location: (0...4))
@ StatementsNode (location: (1,0)-(1,4))
└── body: (length: 1)
└── @ RangeNode (location: (0...4))
└── @ RangeNode (location: (1,0)-(1,4))
├── left: ∅
├── right:
│ @ IntegerNode (location: (3...4))
│ @ IntegerNode (location: (1,3)-(1,4))
│ └── flags: decimal
├── operator_loc: (0...3) = "..."
├── operator_loc: (1,0)-(1,3) = "..."
└── 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: []
└── statements:
@ StatementsNode (location: (0...3))
@ StatementsNode (location: (1,0)-(1,3))
└── body: (length: 1)
└── @ RangeNode (location: (0...3))
└── @ RangeNode (location: (1,0)-(1,3))
├── left: ∅
├── right:
│ @ IntegerNode (location: (2...3))
│ @ IntegerNode (location: (1,2)-(1,3))
│ └── flags: decimal
├── operator_loc: (0...2) = ".."
├── operator_loc: (1,0)-(1,2) = ".."
└── 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: []
└── statements:
@ StatementsNode (location: (0...4))
@ StatementsNode (location: (1,0)-(1,4))
└── body: (length: 1)
└── @ RangeNode (location: (0...4))
└── @ RangeNode (location: (1,0)-(1,4))
├── left:
│ @ IntegerNode (location: (0...1))
│ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal
├── right: ∅
├── operator_loc: (1...4) = "..."
├── operator_loc: (1,1)-(1,4) = "..."
└── 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: []
└── statements:
@ StatementsNode (location: (0...3))
@ StatementsNode (location: (1,0)-(1,3))
└── body: (length: 1)
└── @ RangeNode (location: (0...3))
└── @ RangeNode (location: (1,0)-(1,3))
├── left:
│ @ IntegerNode (location: (0...1))
│ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal
├── right: ∅
├── operator_loc: (1...3) = ".."
├── operator_loc: (1,1)-(1,3) = ".."
└── flags: ∅

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

@ -1,49 +1,49 @@
@ ProgramNode (location: (0...85))
@ ProgramNode (location: (1,0)-(17,5))
├── locals: []
└── statements:
@ StatementsNode (location: (0...85))
@ StatementsNode (location: (1,0)-(17,5))
└── body: (length: 9)
├── @ ParenthesesNode (location: (0...6))
├── @ ParenthesesNode (location: (1,0)-(1,6))
│ ├── body:
│ │ @ StatementsNode (location: (1...5))
│ │ @ StatementsNode (location: (1,1)-(1,5))
│ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (1...5))
│ │ └── @ RangeNode (location: (1,1)-(1,5))
│ │ ├── left: ∅
│ │ ├── right:
│ │ │ @ IntegerNode (location: (4...5))
│ │ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (1...4) = "..."
│ │ ├── operator_loc: (1,1)-(1,4) = "..."
│ │ └── flags: exclude_end
│ ├── opening_loc: (0...1) = "("
│ └── closing_loc: (5...6) = ")"
├── @ ParenthesesNode (location: (8...13))
│ ├── opening_loc: (1,0)-(1,1) = "("
│ └── closing_loc: (1,5)-(1,6) = ")"
├── @ ParenthesesNode (location: (3,0)-(3,5))
│ ├── body:
│ │ @ StatementsNode (location: (9...12))
│ │ @ StatementsNode (location: (3,1)-(3,4))
│ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (9...12))
│ │ └── @ RangeNode (location: (3,1)-(3,4))
│ │ ├── left: ∅
│ │ ├── right:
│ │ │ @ IntegerNode (location: (11...12))
│ │ │ @ IntegerNode (location: (3,3)-(3,4))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (9...11) = ".."
│ │ ├── operator_loc: (3,1)-(3,3) = ".."
│ │ └── flags: ∅
│ ├── opening_loc: (8...9) = "("
│ └── closing_loc: (12...13) = ")"
├── @ RangeNode (location: (15...20))
│ ├── opening_loc: (3,0)-(3,1) = "("
│ └── closing_loc: (3,4)-(3,5) = ")"
├── @ RangeNode (location: (5,0)-(5,5))
│ ├── left:
│ │ @ IntegerNode (location: (15...16))
│ │ @ IntegerNode (location: (5,0)-(5,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (19...20))
│ │ @ IntegerNode (location: (5,4)-(5,5))
│ │ └── flags: decimal
│ ├── operator_loc: (16...19) = "..."
│ ├── operator_loc: (5,1)-(5,4) = "..."
│ └── flags: exclude_end
├── @ CallNode (location: (22...31))
├── @ CallNode (location: (7,0)-(7,9))
│ ├── receiver:
│ │ @ CallNode (location: (22...25))
│ │ @ CallNode (location: (7,0)-(7,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (22...25) = "foo"
│ │ ├── message_loc: (7,0)-(7,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -51,110 +51,110 @@
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── call_operator_loc: ∅
│ ├── message_loc: (25...31) = "[...2]"
│ ├── opening_loc: (25...26) = "["
│ ├── message_loc: (7,3)-(7,9) = "[...2]"
│ ├── opening_loc: (7,3)-(7,4) = "["
│ ├── arguments:
│ │ @ ArgumentsNode (location: (26...30))
│ │ @ ArgumentsNode (location: (7,4)-(7,8))
│ │ └── arguments: (length: 1)
│ │ └── @ RangeNode (location: (26...30))
│ │ └── @ RangeNode (location: (7,4)-(7,8))
│ │ ├── left: ∅
│ │ ├── right:
│ │ │ @ IntegerNode (location: (29...30))
│ │ │ @ IntegerNode (location: (7,7)-(7,8))
│ │ │ └── flags: decimal
│ │ ├── operator_loc: (26...29) = "..."
│ │ ├── operator_loc: (7,4)-(7,7) = "..."
│ │ └── flags: exclude_end
│ ├── closing_loc: (30...31) = "]"
│ ├── closing_loc: (7,8)-(7,9) = "]"
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "[]"
├── @ HashNode (location: (33...48))
│ ├── opening_loc: (33...34) = "{"
├── @ HashNode (location: (9,0)-(9,15))
│ ├── opening_loc: (9,0)-(9,1) = "{"
│ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (35...46))
│ │ └── @ AssocNode (location: (9,2)-(9,13))
│ │ ├── key:
│ │ │ @ SymbolNode (location: (35...39))
│ │ │ @ SymbolNode (location: (9,2)-(9,6))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (35...38) = "foo"
│ │ │ ├── closing_loc: (38...39) = ":"
│ │ │ ├── value_loc: (9,2)-(9,5) = "foo"
│ │ │ ├── closing_loc: (9,5)-(9,6) = ":"
│ │ │ └── unescaped: "foo"
│ │ ├── value:
│ │ │ @ RangeNode (location: (40...46))
│ │ │ @ RangeNode (location: (9,7)-(9,13))
│ │ │ ├── left: ∅
│ │ │ ├── right:
│ │ │ │ @ CallNode (location: (43...46))
│ │ │ │ @ CallNode (location: (9,10)-(9,13))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (43...46) = "bar"
│ │ │ │ ├── message_loc: (9,10)-(9,13) = "bar"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bar"
│ │ │ ├── operator_loc: (40...43) = "..."
│ │ │ ├── operator_loc: (9,7)-(9,10) = "..."
│ │ │ └── flags: exclude_end
│ │ └── operator_loc: ∅
│ └── closing_loc: (47...48) = "}"
├── @ ParenthesesNode (location: (50...56))
│ └── closing_loc: (9,14)-(9,15) = "}"
├── @ ParenthesesNode (location: (11,0)-(11,6))
│ ├── body:
│ │ @ StatementsNode (location: (51...55))
│ │ @ StatementsNode (location: (11,1)-(11,5))
│ │ └── body: (length: 1)
│ │ └── @ RangeNode (location: (51...55))
│ │ └── @ RangeNode (location: (11,1)-(11,5))
│ │ ├── left:
│ │ │ @ IntegerNode (location: (51...52))
│ │ │ @ IntegerNode (location: (11,1)-(11,2))
│ │ │ └── flags: decimal
│ │ ├── right: ∅
│ │ ├── operator_loc: (52...55) = "..."
│ │ ├── operator_loc: (11,2)-(11,5) = "..."
│ │ └── flags: exclude_end
│ ├── opening_loc: (50...51) = "("
│ └── closing_loc: (55...56) = ")"
├── @ RangeNode (location: (58...62))
│ ├── opening_loc: (11,0)-(11,1) = "("
│ └── closing_loc: (11,5)-(11,6) = ")"
├── @ RangeNode (location: (13,0)-(13,4))
│ ├── left:
│ │ @ IntegerNode (location: (58...59))
│ │ @ IntegerNode (location: (13,0)-(13,1))
│ │ └── flags: decimal
│ ├── right:
│ │ @ IntegerNode (location: (61...62))
│ │ @ IntegerNode (location: (13,3)-(13,4))
│ │ └── flags: decimal
│ ├── operator_loc: (59...61) = ".."
│ ├── operator_loc: (13,1)-(13,3) = ".."
│ └── flags: ∅
├── @ HashNode (location: (64...78))
│ ├── opening_loc: (64...65) = "{"
├── @ HashNode (location: (15,0)-(15,14))
│ ├── opening_loc: (15,0)-(15,1) = "{"
│ ├── elements: (length: 1)
│ │ └── @ AssocNode (location: (66...76))
│ │ └── @ AssocNode (location: (15,2)-(15,12))
│ │ ├── key:
│ │ │ @ SymbolNode (location: (66...70))
│ │ │ @ SymbolNode (location: (15,2)-(15,6))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (66...69) = "foo"
│ │ │ ├── closing_loc: (69...70) = ":"
│ │ │ ├── value_loc: (15,2)-(15,5) = "foo"
│ │ │ ├── closing_loc: (15,5)-(15,6) = ":"
│ │ │ └── unescaped: "foo"
│ │ ├── value:
│ │ │ @ RangeNode (location: (71...76))
│ │ │ @ RangeNode (location: (15,7)-(15,12))
│ │ │ ├── left: ∅
│ │ │ ├── right:
│ │ │ │ @ CallNode (location: (73...76))
│ │ │ │ @ CallNode (location: (15,9)-(15,12))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (73...76) = "bar"
│ │ │ │ ├── message_loc: (15,9)-(15,12) = "bar"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bar"
│ │ │ ├── operator_loc: (71...73) = ".."
│ │ │ ├── operator_loc: (15,7)-(15,9) = ".."
│ │ │ └── flags: ∅
│ │ └── operator_loc: ∅
│ └── closing_loc: (77...78) = "}"
└── @ ParenthesesNode (location: (80...85))
│ └── closing_loc: (15,13)-(15,14) = "}"
└── @ ParenthesesNode (location: (17,0)-(17,5))
├── body:
│ @ StatementsNode (location: (81...84))
│ @ StatementsNode (location: (17,1)-(17,4))
│ └── body: (length: 1)
│ └── @ RangeNode (location: (81...84))
│ └── @ RangeNode (location: (17,1)-(17,4))
│ ├── left:
│ │ @ IntegerNode (location: (81...82))
│ │ @ IntegerNode (location: (17,1)-(17,2))
│ │ └── flags: decimal
│ ├── right: ∅
│ ├── operator_loc: (82...84) = ".."
│ ├── operator_loc: (17,2)-(17,4) = ".."
│ └── flags: ∅
├── opening_loc: (80...81) = "("
└── closing_loc: (84...85) = ")"
├── opening_loc: (17,0)-(17,1) = "("
└── 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]
└── statements:
@ StatementsNode (location: (0...293))
@ StatementsNode (location: (1,0)-(30,13))
└── body: (length: 14)
├── @ CallNode (location: (0...9))
├── @ CallNode (location: (1,0)-(1,9))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...3) = "foo"
│ ├── message_loc: (1,0)-(1,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...9))
│ │ @ ArgumentsNode (location: (1,4)-(1,9))
│ │ └── arguments: (length: 1)
│ │ └── @ RegularExpressionNode (location: (4...9))
│ │ ├── opening_loc: (4...5) = "/"
│ │ ├── content_loc: (5...8) = "bar"
│ │ ├── closing_loc: (8...9) = "/"
│ │ └── @ RegularExpressionNode (location: (1,4)-(1,9))
│ │ ├── opening_loc: (1,4)-(1,5) = "/"
│ │ ├── content_loc: (1,5)-(1,8) = "bar"
│ │ ├── closing_loc: (1,8)-(1,9) = "/"
│ │ ├── unescaped: "bar"
│ │ └── flags: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "foo"
├── @ RegularExpressionNode (location: (11...19))
│ ├── opening_loc: (11...14) = "%r{"
│ ├── content_loc: (14...17) = "abc"
│ ├── closing_loc: (17...19) = "}i"
├── @ RegularExpressionNode (location: (3,0)-(3,8))
│ ├── opening_loc: (3,0)-(3,3) = "%r{"
│ ├── content_loc: (3,3)-(3,6) = "abc"
│ ├── closing_loc: (3,6)-(3,8) = "}i"
│ ├── unescaped: "abc"
│ └── flags: ignore_case
├── @ RegularExpressionNode (location: (21...26))
│ ├── opening_loc: (21...22) = "/"
│ ├── content_loc: (22...25) = "a\\b"
│ ├── closing_loc: (25...26) = "/"
├── @ RegularExpressionNode (location: (5,0)-(5,5))
│ ├── opening_loc: (5,0)-(5,1) = "/"
│ ├── content_loc: (5,1)-(5,4) = "a\\b"
│ ├── closing_loc: (5,4)-(5,5) = "/"
│ ├── unescaped: "a\b"
│ └── flags: ∅
├── @ InterpolatedRegularExpressionNode (location: (28...39))
│ ├── opening_loc: (28...29) = "/"
├── @ InterpolatedRegularExpressionNode (location: (7,0)-(7,11))
│ ├── opening_loc: (7,0)-(7,1) = "/"
│ ├── parts: (length: 2)
│ │ ├── @ StringNode (location: (29...33))
│ │ ├── @ StringNode (location: (7,1)-(7,5))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (29...33) = "aaa "
│ │ │ ├── content_loc: (7,1)-(7,5) = "aaa "
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa "
│ │ └── @ EmbeddedVariableNode (location: (33...38))
│ │ ├── operator_loc: (33...34) = "#"
│ │ └── @ EmbeddedVariableNode (location: (7,5)-(7,10))
│ │ ├── operator_loc: (7,5)-(7,6) = "#"
│ │ └── variable:
│ │ @ GlobalVariableReadNode (location: (34...38))
│ │ @ GlobalVariableReadNode (location: (7,6)-(7,10))
│ │ └── name: :$bbb
│ ├── closing_loc: (38...39) = "/"
│ ├── closing_loc: (7,10)-(7,11) = "/"
│ └── flags: ∅
├── @ InterpolatedRegularExpressionNode (location: (41...57))
│ ├── opening_loc: (41...42) = "/"
├── @ InterpolatedRegularExpressionNode (location: (9,0)-(9,16))
│ ├── opening_loc: (9,0)-(9,1) = "/"
│ ├── parts: (length: 3)
│ │ ├── @ StringNode (location: (42...46))
│ │ ├── @ StringNode (location: (9,1)-(9,5))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (42...46) = "aaa "
│ │ │ ├── content_loc: (9,1)-(9,5) = "aaa "
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "aaa "
│ │ ├── @ EmbeddedStatementsNode (location: (46...52))
│ │ │ ├── opening_loc: (46...48) = "\#{"
│ │ ├── @ EmbeddedStatementsNode (location: (9,5)-(9,11))
│ │ │ ├── opening_loc: (9,5)-(9,7) = "\#{"
│ │ │ ├── statements:
│ │ │ │ @ StatementsNode (location: (48...51))
│ │ │ │ @ StatementsNode (location: (9,7)-(9,10))
│ │ │ │ └── body: (length: 1)
│ │ │ │ └── @ CallNode (location: (48...51))
│ │ │ │ └── @ CallNode (location: (9,7)-(9,10))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (48...51) = "bbb"
│ │ │ │ ├── message_loc: (9,7)-(9,10) = "bbb"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "bbb"
│ │ │ └── closing_loc: (51...52) = "}"
│ │ └── @ StringNode (location: (52...56))
│ │ │ └── closing_loc: (9,10)-(9,11) = "}"
│ │ └── @ StringNode (location: (9,11)-(9,15))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (52...56) = " ccc"
│ │ ├── content_loc: (9,11)-(9,15) = " ccc"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: " ccc"
│ ├── closing_loc: (56...57) = "/"
│ ├── closing_loc: (9,15)-(9,16) = "/"
│ └── flags: ∅
├── @ ArrayNode (location: (59...86))
├── @ ArrayNode (location: (11,0)-(11,27))
│ ├── elements: (length: 2)
│ │ ├── @ MatchWriteNode (location: (60...80))
│ │ ├── @ MatchWriteNode (location: (11,1)-(11,21))
│ │ │ ├── call:
│ │ │ │ @ CallNode (location: (60...80))
│ │ │ │ @ CallNode (location: (11,1)-(11,21))
│ │ │ │ ├── receiver:
│ │ │ │ │ @ RegularExpressionNode (location: (60...73))
│ │ │ │ │ ├── opening_loc: (60...61) = "/"
│ │ │ │ │ ├── content_loc: (61...72) = "(?<foo>bar)"
│ │ │ │ │ ├── closing_loc: (72...73) = "/"
│ │ │ │ │ @ RegularExpressionNode (location: (11,1)-(11,14))
│ │ │ │ │ ├── opening_loc: (11,1)-(11,2) = "/"
│ │ │ │ │ ├── content_loc: (11,2)-(11,13) = "(?<foo>bar)"
│ │ │ │ │ ├── closing_loc: (11,13)-(11,14) = "/"
│ │ │ │ │ ├── unescaped: "(?<foo>bar)"
│ │ │ │ │ └── flags: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (74...76) = "=~"
│ │ │ │ ├── message_loc: (11,15)-(11,17) = "=~"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (77...80))
│ │ │ │ │ @ ArgumentsNode (location: (11,18)-(11,21))
│ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (77...80))
│ │ │ │ │ └── @ CallNode (location: (11,18)-(11,21))
│ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (77...80) = "baz"
│ │ │ │ │ ├── message_loc: (11,18)-(11,21) = "baz"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
@ -115,95 +115,95 @@
│ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "=~"
│ │ │ └── locals: [:foo]
│ │ └── @ LocalVariableReadNode (location: (82...85))
│ │ └── @ LocalVariableReadNode (location: (11,23)-(11,26))
│ │ ├── name: :foo
│ │ └── depth: 0
│ ├── opening_loc: (59...60) = "["
│ └── closing_loc: (85...86) = "]"
├── @ RegularExpressionNode (location: (88...94))
│ ├── opening_loc: (88...89) = "/"
│ ├── content_loc: (89...92) = "abc"
│ ├── closing_loc: (92...94) = "/i"
│ ├── opening_loc: (11,0)-(11,1) = "["
│ └── closing_loc: (11,26)-(11,27) = "]"
├── @ RegularExpressionNode (location: (13,0)-(13,6))
│ ├── opening_loc: (13,0)-(13,1) = "/"
│ ├── content_loc: (13,1)-(13,4) = "abc"
│ ├── closing_loc: (13,4)-(13,6) = "/i"
│ ├── unescaped: "abc"
│ └── flags: ignore_case
├── @ RegularExpressionNode (location: (96...122))
│ ├── opening_loc: (96...99) = "%r/"
│ ├── content_loc: (99...120) = "[a-z$._?][\\w$.?\#@~]*:"
│ ├── closing_loc: (120...122) = "/i"
├── @ RegularExpressionNode (location: (15,0)-(15,26))
│ ├── opening_loc: (15,0)-(15,3) = "%r/"
│ ├── content_loc: (15,3)-(15,24) = "[a-z$._?][\\w$.?\#@~]*:"
│ ├── closing_loc: (15,24)-(15,26) = "/i"
│ ├── unescaped: "[a-z$._?][w$.?\#@~]*:"
│ └── flags: ignore_case
├── @ RegularExpressionNode (location: (124...161))
│ ├── opening_loc: (124...127) = "%r/"
│ ├── content_loc: (127...159) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
│ ├── closing_loc: (159...161) = "/i"
├── @ RegularExpressionNode (location: (17,0)-(17,37))
│ ├── opening_loc: (17,0)-(17,3) = "%r/"
│ ├── content_loc: (17,3)-(17,35) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
│ ├── closing_loc: (17,35)-(17,37) = "/i"
│ ├── unescaped: "([a-z$._?][w$.?\#@~]*)( +)(equ)"
│ └── flags: ignore_case
├── @ RegularExpressionNode (location: (163...188))
│ ├── opening_loc: (163...166) = "%r/"
│ ├── content_loc: (166...186) = "[a-z$._?][\\w$.?\#@~]*"
│ ├── closing_loc: (186...188) = "/i"
├── @ RegularExpressionNode (location: (19,0)-(19,25))
│ ├── opening_loc: (19,0)-(19,3) = "%r/"
│ ├── content_loc: (19,3)-(19,23) = "[a-z$._?][\\w$.?\#@~]*"
│ ├── closing_loc: (19,23)-(19,25) = "/i"
│ ├── unescaped: "[a-z$._?][w$.?\#@~]*"
│ └── flags: ignore_case
├── @ RegularExpressionNode (location: (190...249))
│ ├── opening_loc: (190...193) = "%r("
│ ├── content_loc: (193...248) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\\w\#$%_']+)\n"
│ ├── closing_loc: (248...249) = ")"
├── @ RegularExpressionNode (location: (21,0)-(24,1))
│ ├── opening_loc: (21,0)-(21,3) = "%r("
│ ├── content_loc: (21,3)-(23,0) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n (?:[\\w\#$%_']+)\n"
│ ├── closing_loc: (24,0)-(24,1) = ")"
│ ├── unescaped: "\n(?:[w\#$%_']|()|(,)|[]|[0-9])*\n (?:[w\#$%_']+)\n"
│ └── flags: ∅
├── @ CallNode (location: (251...267))
├── @ CallNode (location: (26,0)-(26,16))
│ ├── receiver:
│ │ @ RegularExpressionNode (location: (251...259))
│ │ ├── opening_loc: (251...252) = "/"
│ │ ├── content_loc: (252...258) = "(?#\\))"
│ │ ├── closing_loc: (258...259) = "/"
│ │ @ RegularExpressionNode (location: (26,0)-(26,8))
│ │ ├── opening_loc: (26,0)-(26,1) = "/"
│ │ ├── content_loc: (26,1)-(26,7) = "(?#\\))"
│ │ ├── closing_loc: (26,7)-(26,8) = "/"
│ │ ├── unescaped: "(?#))"
│ │ └── flags: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (260...262) = "=~"
│ ├── message_loc: (26,9)-(26,11) = "=~"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (263...267))
│ │ @ ArgumentsNode (location: (26,12)-(26,16))
│ │ └── arguments: (length: 1)
│ │ └── @ StringNode (location: (263...267))
│ │ └── @ StringNode (location: (26,12)-(26,16))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (263...264) = "\""
│ │ ├── content_loc: (264...266) = "hi"
│ │ ├── closing_loc: (266...267) = "\""
│ │ ├── opening_loc: (26,12)-(26,13) = "\""
│ │ ├── content_loc: (26,13)-(26,15) = "hi"
│ │ ├── closing_loc: (26,15)-(26,16) = "\""
│ │ └── unescaped: "hi"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "=~"
├── @ RegularExpressionNode (location: (269...278))
│ ├── opening_loc: (269...272) = "%r#"
│ ├── content_loc: (272...277) = "pound"
│ ├── closing_loc: (277...278) = "#"
├── @ RegularExpressionNode (location: (28,0)-(28,9))
│ ├── opening_loc: (28,0)-(28,3) = "%r#"
│ ├── content_loc: (28,3)-(28,8) = "pound"
│ ├── closing_loc: (28,8)-(28,9) = "#"
│ ├── unescaped: "pound"
│ └── flags: ∅
└── @ InterpolatedRegularExpressionNode (location: (280...293))
├── opening_loc: (280...281) = "/"
└── @ InterpolatedRegularExpressionNode (location: (30,0)-(30,13))
├── opening_loc: (30,0)-(30,1) = "/"
├── parts: (length: 2)
│ ├── @ StringNode (location: (281...285))
│ ├── @ StringNode (location: (30,1)-(30,5))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (281...285) = "aaa "
│ │ ├── content_loc: (30,1)-(30,5) = "aaa "
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "aaa "
│ └── @ EmbeddedStatementsNode (location: (285...291))
│ ├── opening_loc: (285...287) = "\#{"
│ └── @ EmbeddedStatementsNode (location: (30,5)-(30,11))
│ ├── opening_loc: (30,5)-(30,7) = "\#{"
│ ├── statements:
│ │ @ StatementsNode (location: (287...290))
│ │ @ StatementsNode (location: (30,7)-(30,10))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (287...290))
│ │ └── @ CallNode (location: (30,7)-(30,10))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (287...290) = "bbb"
│ │ ├── message_loc: (30,7)-(30,10) = "bbb"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "bbb"
│ └── closing_loc: (290...291) = "}"
├── closing_loc: (291...293) = "/o"
│ └── closing_loc: (30,10)-(30,11) = "}"
├── closing_loc: (30,11)-(30,13) = "/o"
└── 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]
└── statements:
@ StatementsNode (location: (0...316))
@ StatementsNode (location: (1,0)-(31,3))
└── body: (length: 12)
├── @ RescueModifierNode (location: (0...14))
├── @ RescueModifierNode (location: (1,0)-(1,14))
│ ├── expression:
│ │ @ CallNode (location: (0...3))
│ │ @ CallNode (location: (1,0)-(1,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...3) = "foo"
│ │ ├── message_loc: (1,0)-(1,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── keyword_loc: (4...10) = "rescue"
│ ├── keyword_loc: (1,4)-(1,10) = "rescue"
│ └── rescue_expression:
│ @ NilNode (location: (11...14))
├── @ RescueModifierNode (location: (16...30))
│ @ NilNode (location: (1,11)-(1,14))
├── @ RescueModifierNode (location: (3,0)-(4,3))
│ ├── expression:
│ │ @ CallNode (location: (16...19))
│ │ @ CallNode (location: (3,0)-(3,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (16...19) = "foo"
│ │ ├── message_loc: (3,0)-(3,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── keyword_loc: (20...26) = "rescue"
│ ├── keyword_loc: (3,4)-(3,10) = "rescue"
│ └── rescue_expression:
│ @ NilNode (location: (27...30))
├── @ RescueModifierNode (location: (32...48))
│ @ NilNode (location: (4,0)-(4,3))
├── @ RescueModifierNode (location: (6,0)-(6,16))
│ ├── expression:
│ │ @ BreakNode (location: (32...37))
│ │ @ BreakNode (location: (6,0)-(6,5))
│ │ ├── arguments: ∅
│ │ └── keyword_loc: (32...37) = "break"
│ ├── keyword_loc: (38...44) = "rescue"
│ │ └── keyword_loc: (6,0)-(6,5) = "break"
│ ├── keyword_loc: (6,6)-(6,12) = "rescue"
│ └── rescue_expression:
│ @ NilNode (location: (45...48))
├── @ RescueModifierNode (location: (50...65))
│ @ NilNode (location: (6,13)-(6,16))
├── @ RescueModifierNode (location: (8,0)-(8,15))
│ ├── expression:
│ │ @ NextNode (location: (50...54))
│ │ @ NextNode (location: (8,0)-(8,4))
│ │ ├── arguments: ∅
│ │ └── keyword_loc: (50...54) = "next"
│ ├── keyword_loc: (55...61) = "rescue"
│ │ └── keyword_loc: (8,0)-(8,4) = "next"
│ ├── keyword_loc: (8,5)-(8,11) = "rescue"
│ └── rescue_expression:
│ @ NilNode (location: (62...65))
├── @ RescueModifierNode (location: (67...84))
│ @ NilNode (location: (8,12)-(8,15))
├── @ RescueModifierNode (location: (10,0)-(10,17))
│ ├── expression:
│ │ @ ReturnNode (location: (67...73))
│ │ ├── keyword_loc: (67...73) = "return"
│ │ @ ReturnNode (location: (10,0)-(10,6))
│ │ ├── keyword_loc: (10,0)-(10,6) = "return"
│ │ └── arguments: ∅
│ ├── keyword_loc: (74...80) = "rescue"
│ ├── keyword_loc: (10,7)-(10,13) = "rescue"
│ └── rescue_expression:
│ @ NilNode (location: (81...84))
├── @ RescueModifierNode (location: (86...105))
│ @ NilNode (location: (10,14)-(10,17))
├── @ RescueModifierNode (location: (12,0)-(12,19))
│ ├── expression:
│ │ @ CallNode (location: (86...89))
│ │ @ CallNode (location: (12,0)-(12,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (86...89) = "foo"
│ │ ├── message_loc: (12,0)-(12,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── keyword_loc: (90...96) = "rescue"
│ ├── keyword_loc: (12,4)-(12,10) = "rescue"
│ └── rescue_expression:
│ @ OrNode (location: (97...105))
│ @ OrNode (location: (12,11)-(12,19))
│ ├── left:
│ │ @ NilNode (location: (97...100))
│ │ @ NilNode (location: (12,11)-(12,14))
│ ├── right:
│ │ @ IntegerNode (location: (104...105))
│ │ @ IntegerNode (location: (12,18)-(12,19))
│ │ └── flags: decimal
│ └── operator_loc: (101...103) = "||"
├── @ RescueModifierNode (location: (107...129))
│ └── operator_loc: (12,15)-(12,17) = "||"
├── @ RescueModifierNode (location: (14,0)-(14,22))
│ ├── expression:
│ │ @ CallNode (location: (107...110))
│ │ @ CallNode (location: (14,0)-(14,3))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (107...110) = "foo"
│ │ ├── message_loc: (14,0)-(14,3) = "foo"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "foo"
│ ├── keyword_loc: (111...117) = "rescue"
│ ├── keyword_loc: (14,4)-(14,10) = "rescue"
│ └── rescue_expression:
│ @ IfNode (location: (118...129))
│ @ IfNode (location: (14,11)-(14,22))
│ ├── if_keyword_loc: ∅
│ ├── predicate:
│ │ @ NilNode (location: (118...121))
│ │ @ NilNode (location: (14,11)-(14,14))
│ ├── statements:
│ │ @ StatementsNode (location: (124...125))
│ │ @ StatementsNode (location: (14,17)-(14,18))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (124...125))
│ │ └── @ IntegerNode (location: (14,17)-(14,18))
│ │ └── flags: decimal
│ ├── consequent:
│ │ @ ElseNode (location: (126...129))
│ │ ├── else_keyword_loc: (126...127) = ":"
│ │ @ ElseNode (location: (14,19)-(14,22))
│ │ ├── else_keyword_loc: (14,19)-(14,20) = ":"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (128...129))
│ │ │ @ StatementsNode (location: (14,21)-(14,22))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (128...129))
│ │ │ └── @ IntegerNode (location: (14,21)-(14,22))
│ │ │ └── flags: decimal
│ │ └── end_keyword_loc: ∅
│ └── end_keyword_loc: ∅
├── @ BeginNode (location: (131...155))
│ ├── begin_keyword_loc: (131...136) = "begin"
├── @ BeginNode (location: (16,0)-(16,24))
│ ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
│ ├── statements:
│ │ @ StatementsNode (location: (138...139))
│ │ @ StatementsNode (location: (16,7)-(16,8))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (138...139))
│ │ └── @ CallNode (location: (16,7)-(16,8))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (138...139) = "a"
│ │ ├── message_loc: (16,7)-(16,8) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -127,16 +127,16 @@
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (141...150))
│ │ ├── keyword_loc: (141...147) = "rescue"
│ │ @ RescueNode (location: (16,10)-(16,19))
│ │ ├── keyword_loc: (16,10)-(16,16) = "rescue"
│ │ ├── exceptions: (length: 1)
│ │ │ └── @ SplatNode (location: (148...150))
│ │ │ ├── operator_loc: (148...149) = "*"
│ │ │ └── @ SplatNode (location: (16,17)-(16,19))
│ │ │ ├── operator_loc: (16,17)-(16,18) = "*"
│ │ │ └── expression:
│ │ │ @ CallNode (location: (149...150))
│ │ │ @ CallNode (location: (16,18)-(16,19))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (149...150) = "b"
│ │ │ ├── message_loc: (16,18)-(16,19) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -149,23 +149,23 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (152...155) = "end"
├── @ CallNode (location: (157...212))
│ └── end_keyword_loc: (16,21)-(16,24) = "end"
├── @ CallNode (location: (18,0)-(20,3))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (157...160) = "foo"
│ ├── message_loc: (18,0)-(18,3) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (161...212))
│ │ @ BlockNode (location: (18,4)-(20,3))
│ │ ├── locals: [:x]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (164...167))
│ │ │ @ BlockParametersNode (location: (18,7)-(18,10))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (165...166))
│ │ │ │ @ ParametersNode (location: (18,8)-(18,9))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (165...166))
│ │ │ │ │ └── @ RequiredParameterNode (location: (18,8)-(18,9))
│ │ │ │ │ └── name: :x
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -174,58 +174,58 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (164...165) = "|"
│ │ │ └── closing_loc: (166...167) = "|"
│ │ │ ├── opening_loc: (18,7)-(18,8) = "|"
│ │ │ └── closing_loc: (18,9)-(18,10) = "|"
│ │ ├── body:
│ │ │ @ StatementsNode (location: (170...208))
│ │ │ @ StatementsNode (location: (19,2)-(19,40))
│ │ │ └── body: (length: 1)
│ │ │ └── @ RescueModifierNode (location: (170...208))
│ │ │ └── @ RescueModifierNode (location: (19,2)-(19,40))
│ │ │ ├── expression:
│ │ │ │ @ CallNode (location: (170...176))
│ │ │ │ @ CallNode (location: (19,2)-(19,8))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (170...173) = "bar"
│ │ │ │ ├── opening_loc: (173...174) = "("
│ │ │ │ ├── message_loc: (19,2)-(19,5) = "bar"
│ │ │ │ ├── opening_loc: (19,5)-(19,6) = "("
│ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (174...175))
│ │ │ │ │ @ ArgumentsNode (location: (19,6)-(19,7))
│ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ CallNode (location: (174...175))
│ │ │ │ │ └── @ CallNode (location: (19,6)-(19,7))
│ │ │ │ │ ├── receiver: ∅
│ │ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ │ ├── message_loc: (174...175) = "y"
│ │ │ │ │ ├── message_loc: (19,6)-(19,7) = "y"
│ │ │ │ │ ├── opening_loc: ∅
│ │ │ │ │ ├── arguments: ∅
│ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ ├── block: ∅
│ │ │ │ │ ├── flags: variable_call
│ │ │ │ │ └── name: "y"
│ │ │ │ ├── closing_loc: (175...176) = ")"
│ │ │ │ ├── closing_loc: (19,7)-(19,8) = ")"
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: ∅
│ │ │ │ └── name: "bar"
│ │ │ ├── keyword_loc: (177...183) = "rescue"
│ │ │ ├── keyword_loc: (19,9)-(19,15) = "rescue"
│ │ │ └── rescue_expression:
│ │ │ @ CallNode (location: (184...208))
│ │ │ @ CallNode (location: (19,16)-(19,40))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (184...197) = "ArgumentError"
│ │ │ ├── message_loc: (19,16)-(19,29) = "ArgumentError"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (198...208))
│ │ │ │ @ ArgumentsNode (location: (19,30)-(19,40))
│ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ CallNode (location: (198...208))
│ │ │ │ └── @ CallNode (location: (19,30)-(19,40))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (198...202) = "fail"
│ │ │ │ ├── message_loc: (19,30)-(19,34) = "fail"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments:
│ │ │ │ │ @ ArgumentsNode (location: (203...208))
│ │ │ │ │ @ ArgumentsNode (location: (19,35)-(19,40))
│ │ │ │ │ └── arguments: (length: 1)
│ │ │ │ │ └── @ StringNode (location: (203...208))
│ │ │ │ │ └── @ StringNode (location: (19,35)-(19,40))
│ │ │ │ │ ├── flags: ∅
│ │ │ │ │ ├── opening_loc: (203...204) = "\""
│ │ │ │ │ ├── content_loc: (204...207) = "baz"
│ │ │ │ │ ├── closing_loc: (207...208) = "\""
│ │ │ │ │ ├── opening_loc: (19,35)-(19,36) = "\""
│ │ │ │ │ ├── content_loc: (19,36)-(19,39) = "baz"
│ │ │ │ │ ├── closing_loc: (19,39)-(19,40) = "\""
│ │ │ │ │ └── unescaped: "baz"
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
@ -235,41 +235,41 @@
│ │ │ ├── block: ∅
│ │ │ ├── flags: ∅
│ │ │ └── name: "ArgumentError"
│ │ ├── opening_loc: (161...163) = "do"
│ │ └── closing_loc: (209...212) = "end"
│ │ ├── opening_loc: (18,4)-(18,6) = "do"
│ │ └── closing_loc: (20,0)-(20,3) = "end"
│ ├── flags: ∅
│ └── name: "foo"
├── @ IfNode (location: (214...245))
│ ├── if_keyword_loc: (214...216) = "if"
├── @ IfNode (location: (22,0)-(24,3))
│ ├── if_keyword_loc: (22,0)-(22,2) = "if"
│ ├── predicate:
│ │ @ LocalVariableWriteNode (location: (217...235))
│ │ @ LocalVariableWriteNode (location: (22,3)-(22,21))
│ │ ├── name: :a
│ │ ├── depth: 0
│ │ ├── name_loc: (217...218) = "a"
│ │ ├── name_loc: (22,3)-(22,4) = "a"
│ │ ├── value:
│ │ │ @ RescueModifierNode (location: (221...235))
│ │ │ @ RescueModifierNode (location: (22,7)-(22,21))
│ │ │ ├── expression:
│ │ │ │ @ CallNode (location: (221...224))
│ │ │ │ @ CallNode (location: (22,7)-(22,10))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (221...224) = "foo"
│ │ │ │ ├── message_loc: (22,7)-(22,10) = "foo"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ ├── block: ∅
│ │ │ │ ├── flags: variable_call
│ │ │ │ └── name: "foo"
│ │ │ ├── keyword_loc: (225...231) = "rescue"
│ │ │ ├── keyword_loc: (22,11)-(22,17) = "rescue"
│ │ │ └── rescue_expression:
│ │ │ @ NilNode (location: (232...235))
│ │ └── operator_loc: (219...220) = "="
│ │ │ @ NilNode (location: (22,18)-(22,21))
│ │ └── operator_loc: (22,5)-(22,6) = "="
│ ├── statements:
│ │ @ StatementsNode (location: (238...241))
│ │ @ StatementsNode (location: (23,2)-(23,5))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (238...241))
│ │ └── @ CallNode (location: (23,2)-(23,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (238...241) = "bar"
│ │ ├── message_loc: (23,2)-(23,5) = "bar"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -277,76 +277,76 @@
│ │ ├── flags: variable_call
│ │ └── name: "bar"
│ ├── consequent: ∅
│ └── end_keyword_loc: (242...245) = "end"
├── @ DefNode (location: (247...291))
│ └── end_keyword_loc: (24,0)-(24,3) = "end"
├── @ DefNode (location: (26,0)-(26,44))
│ ├── name: :some_method
│ ├── name_loc: (251...262) = "some_method"
│ ├── name_loc: (26,4)-(26,15) = "some_method"
│ ├── receiver: ∅
│ ├── parameters: ∅
│ ├── body:
│ │ @ StatementsNode (location: (265...291))
│ │ @ StatementsNode (location: (26,18)-(26,44))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (265...291))
│ │ └── @ CallNode (location: (26,18)-(26,44))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (265...277) = "other_method"
│ │ ├── message_loc: (26,18)-(26,30) = "other_method"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (278...291))
│ │ │ @ ArgumentsNode (location: (26,31)-(26,44))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ RescueModifierNode (location: (278...291))
│ │ │ └── @ RescueModifierNode (location: (26,31)-(26,44))
│ │ │ ├── expression:
│ │ │ │ @ IntegerNode (location: (278...280))
│ │ │ │ @ IntegerNode (location: (26,31)-(26,33))
│ │ │ │ └── flags: decimal
│ │ │ ├── keyword_loc: (281...287) = "rescue"
│ │ │ ├── keyword_loc: (26,34)-(26,40) = "rescue"
│ │ │ └── rescue_expression:
│ │ │ @ NilNode (location: (288...291))
│ │ │ @ NilNode (location: (26,41)-(26,44))
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "other_method"
│ ├── locals: []
│ ├── def_keyword_loc: (247...250) = "def"
│ ├── def_keyword_loc: (26,0)-(26,3) = "def"
│ ├── operator_loc: ∅
│ ├── lparen_loc: ∅
│ ├── rparen_loc: ∅
│ ├── equal_loc: (263...264) = "="
│ ├── equal_loc: (26,16)-(26,17) = "="
│ └── end_keyword_loc: ∅
└── @ DefNode (location: (293...316))
└── @ DefNode (location: (28,0)-(31,3))
├── name: :a
├── name_loc: (297...298) = "a"
├── name_loc: (28,4)-(28,5) = "a"
├── receiver: ∅
├── parameters: ∅
├── body:
│ @ BeginNode (location: (301...316))
│ @ BeginNode (location: (29,2)-(31,3))
│ ├── begin_keyword_loc: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (301...305))
│ │ @ StatementsNode (location: (29,2)-(29,6))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (301...305))
│ │ └── @ CallNode (location: (29,2)-(29,6))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (301...302) = "a"
│ │ ├── message_loc: (29,2)-(29,3) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments:
│ │ │ @ ArgumentsNode (location: (303...305))
│ │ │ @ ArgumentsNode (location: (29,4)-(29,6))
│ │ │ └── arguments: (length: 1)
│ │ │ └── @ KeywordHashNode (location: (303...305))
│ │ │ └── @ KeywordHashNode (location: (29,4)-(29,6))
│ │ │ └── elements: (length: 1)
│ │ │ └── @ AssocNode (location: (303...305))
│ │ │ └── @ AssocNode (location: (29,4)-(29,6))
│ │ │ ├── key:
│ │ │ │ @ SymbolNode (location: (303...305))
│ │ │ │ @ SymbolNode (location: (29,4)-(29,6))
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── value_loc: (303...304) = "b"
│ │ │ │ ├── closing_loc: (304...305) = ":"
│ │ │ │ ├── value_loc: (29,4)-(29,5) = "b"
│ │ │ │ ├── closing_loc: (29,5)-(29,6) = ":"
│ │ │ │ └── unescaped: "b"
│ │ │ ├── value:
│ │ │ │ @ ImplicitNode (location: (303...305))
│ │ │ │ @ ImplicitNode (location: (29,4)-(29,6))
│ │ │ │ └── value:
│ │ │ │ @ CallNode (location: (303...305))
│ │ │ │ @ CallNode (location: (29,4)-(29,6))
│ │ │ │ ├── receiver: ∅
│ │ │ │ ├── call_operator_loc: ∅
│ │ │ │ ├── message_loc: (303...304) = "b"
│ │ │ │ ├── message_loc: (29,4)-(29,5) = "b"
│ │ │ │ ├── opening_loc: ∅
│ │ │ │ ├── arguments: ∅
│ │ │ │ ├── closing_loc: ∅
@ -359,8 +359,8 @@
│ │ ├── flags: ∅
│ │ └── name: "a"
│ ├── rescue_clause:
│ │ @ RescueNode (location: (306...312))
│ │ ├── keyword_loc: (306...312) = "rescue"
│ │ @ RescueNode (location: (30,0)-(30,6))
│ │ ├── keyword_loc: (30,0)-(30,6) = "rescue"
│ │ ├── exceptions: (length: 0)
│ │ ├── operator_loc: ∅
│ │ ├── reference: ∅
@ -368,11 +368,11 @@
│ │ └── consequent: ∅
│ ├── else_clause: ∅
│ ├── ensure_clause: ∅
│ └── end_keyword_loc: (313...316) = "end"
│ └── end_keyword_loc: (31,0)-(31,3) = "end"
├── locals: []
├── def_keyword_loc: (293...296) = "def"
├── def_keyword_loc: (28,0)-(28,3) = "def"
├── operator_loc: ∅
├── lparen_loc: ∅
├── rparen_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: []
└── statements:
@ StatementsNode (location: (0...139))
@ StatementsNode (location: (1,0)-(23,9))
└── body: (length: 10)
├── @ ReturnNode (location: (0...6))
│ ├── keyword_loc: (0...6) = "return"
├── @ ReturnNode (location: (1,0)-(1,6))
│ ├── keyword_loc: (1,0)-(1,6) = "return"
│ └── arguments: ∅
├── @ ReturnNode (location: (8...28))
│ ├── keyword_loc: (8...14) = "return"
├── @ ReturnNode (location: (3,0)-(3,20))
│ ├── keyword_loc: (3,0)-(3,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (15...28))
│ @ ArgumentsNode (location: (3,7)-(3,20))
│ └── arguments: (length: 3)
│ ├── @ ParenthesesNode (location: (15...18))
│ ├── @ ParenthesesNode (location: (3,7)-(3,10))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (16...17))
│ │ │ @ StatementsNode (location: (3,8)-(3,9))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (16...17))
│ │ │ └── @ IntegerNode (location: (3,8)-(3,9))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (15...16) = "("
│ │ └── closing_loc: (17...18) = ")"
│ ├── @ ParenthesesNode (location: (20...23))
│ │ ├── opening_loc: (3,7)-(3,8) = "("
│ │ └── closing_loc: (3,9)-(3,10) = ")"
│ ├── @ ParenthesesNode (location: (3,12)-(3,15))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (21...22))
│ │ │ @ StatementsNode (location: (3,13)-(3,14))
│ │ │ └── body: (length: 1)
│ │ │ └── @ IntegerNode (location: (21...22))
│ │ │ └── @ IntegerNode (location: (3,13)-(3,14))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (20...21) = "("
│ │ └── closing_loc: (22...23) = ")"
│ └── @ ParenthesesNode (location: (25...28))
│ │ ├── opening_loc: (3,12)-(3,13) = "("
│ │ └── closing_loc: (3,14)-(3,15) = ")"
│ └── @ ParenthesesNode (location: (3,17)-(3,20))
│ ├── body:
│ │ @ StatementsNode (location: (26...27))
│ │ @ StatementsNode (location: (3,18)-(3,19))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (26...27))
│ │ └── @ IntegerNode (location: (3,18)-(3,19))
│ │ └── flags: decimal
│ ├── opening_loc: (25...26) = "("
│ └── closing_loc: (27...28) = ")"
├── @ ReturnNode (location: (30...39))
│ ├── keyword_loc: (30...36) = "return"
│ ├── opening_loc: (3,17)-(3,18) = "("
│ └── closing_loc: (3,19)-(3,20) = ")"
├── @ ReturnNode (location: (5,0)-(5,9))
│ ├── keyword_loc: (5,0)-(5,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (37...39))
│ @ ArgumentsNode (location: (5,7)-(5,9))
│ └── arguments: (length: 1)
│ └── @ SplatNode (location: (37...39))
│ ├── operator_loc: (37...38) = "*"
│ └── @ SplatNode (location: (5,7)-(5,9))
│ ├── operator_loc: (5,7)-(5,8) = "*"
│ └── expression:
│ @ IntegerNode (location: (38...39))
│ @ IntegerNode (location: (5,8)-(5,9))
│ └── flags: decimal
├── @ ReturnNode (location: (41...49))
│ ├── keyword_loc: (41...47) = "return"
├── @ ReturnNode (location: (7,0)-(7,8))
│ ├── keyword_loc: (7,0)-(7,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (48...49))
│ @ ArgumentsNode (location: (7,7)-(7,8))
│ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (48...49))
│ └── @ IntegerNode (location: (7,7)-(7,8))
│ └── flags: decimal
├── @ ReturnNode (location: (51...65))
│ ├── keyword_loc: (51...57) = "return"
├── @ ReturnNode (location: (9,0)-(10,1))
│ ├── keyword_loc: (9,0)-(9,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (58...65))
│ @ ArgumentsNode (location: (9,7)-(10,1))
│ └── arguments: (length: 3)
│ ├── @ IntegerNode (location: (58...59))
│ ├── @ IntegerNode (location: (9,7)-(9,8))
│ │ └── flags: decimal
│ ├── @ IntegerNode (location: (61...62))
│ ├── @ IntegerNode (location: (9,10)-(9,11))
│ │ └── flags: decimal
│ └── @ IntegerNode (location: (64...65))
│ └── @ IntegerNode (location: (10,0)-(10,1))
│ └── flags: decimal
├── @ ReturnNode (location: (67...81))
│ ├── keyword_loc: (67...73) = "return"
├── @ ReturnNode (location: (12,0)-(12,14))
│ ├── keyword_loc: (12,0)-(12,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (74...81))
│ @ ArgumentsNode (location: (12,7)-(12,14))
│ └── arguments: (length: 3)
│ ├── @ IntegerNode (location: (74...75))
│ ├── @ IntegerNode (location: (12,7)-(12,8))
│ │ └── flags: decimal
│ ├── @ IntegerNode (location: (77...78))
│ ├── @ IntegerNode (location: (12,10)-(12,11))
│ │ └── flags: decimal
│ └── @ IntegerNode (location: (80...81))
│ └── @ IntegerNode (location: (12,13)-(12,14))
│ └── flags: decimal
├── @ ReturnNode (location: (83...99))
│ ├── keyword_loc: (83...89) = "return"
├── @ ReturnNode (location: (14,0)-(14,16))
│ ├── keyword_loc: (14,0)-(14,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (90...99))
│ @ ArgumentsNode (location: (14,7)-(14,16))
│ └── arguments: (length: 1)
│ └── @ ArrayNode (location: (90...99))
│ └── @ ArrayNode (location: (14,7)-(14,16))
│ ├── elements: (length: 3)
│ │ ├── @ IntegerNode (location: (91...92))
│ │ ├── @ IntegerNode (location: (14,8)-(14,9))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (94...95))
│ │ ├── @ IntegerNode (location: (14,11)-(14,12))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (97...98))
│ │ └── @ IntegerNode (location: (14,14)-(14,15))
│ │ └── flags: decimal
│ ├── opening_loc: (90...91) = "["
│ └── closing_loc: (98...99) = "]"
├── @ ReturnNode (location: (101...118))
│ ├── keyword_loc: (101...107) = "return"
│ ├── opening_loc: (14,7)-(14,8) = "["
│ └── closing_loc: (14,15)-(14,16) = "]"
├── @ ReturnNode (location: (16,0)-(19,1))
│ ├── keyword_loc: (16,0)-(16,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (107...118))
│ @ ArgumentsNode (location: (16,6)-(19,1))
│ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (107...118))
│ └── @ ParenthesesNode (location: (16,6)-(19,1))
│ ├── body:
│ │ @ StatementsNode (location: (111...116))
│ │ @ StatementsNode (location: (17,2)-(18,3))
│ │ └── body: (length: 2)
│ │ ├── @ IntegerNode (location: (111...112))
│ │ ├── @ IntegerNode (location: (17,2)-(17,3))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (115...116))
│ │ └── @ IntegerNode (location: (18,2)-(18,3))
│ │ └── flags: decimal
│ ├── opening_loc: (107...108) = "("
│ └── closing_loc: (117...118) = ")"
├── @ ReturnNode (location: (120...128))
│ ├── keyword_loc: (120...126) = "return"
│ ├── opening_loc: (16,6)-(16,7) = "("
│ └── closing_loc: (19,0)-(19,1) = ")"
├── @ ReturnNode (location: (21,0)-(21,8))
│ ├── keyword_loc: (21,0)-(21,6) = "return"
│ └── arguments:
│ @ ArgumentsNode (location: (126...128))
│ @ ArgumentsNode (location: (21,6)-(21,8))
│ └── arguments: (length: 1)
│ └── @ ParenthesesNode (location: (126...128))
│ └── @ ParenthesesNode (location: (21,6)-(21,8))
│ ├── body: ∅
│ ├── opening_loc: (126...127) = "("
│ └── closing_loc: (127...128) = ")"
└── @ ReturnNode (location: (130...139))
├── keyword_loc: (130...136) = "return"
│ ├── opening_loc: (21,6)-(21,7) = "("
│ └── closing_loc: (21,7)-(21,8) = ")"
└── @ ReturnNode (location: (23,0)-(23,9))
├── keyword_loc: (23,0)-(23,6) = "return"
└── arguments:
@ ArgumentsNode (location: (136...139))
@ ArgumentsNode (location: (23,6)-(23,9))
└── arguments: (length: 1)
└── @ ParenthesesNode (location: (136...139))
└── @ ParenthesesNode (location: (23,6)-(23,9))
├── body:
│ @ StatementsNode (location: (137...138))
│ @ StatementsNode (location: (23,7)-(23,8))
│ └── body: (length: 1)
│ └── @ IntegerNode (location: (137...138))
│ └── @ IntegerNode (location: (23,7)-(23,8))
│ └── flags: decimal
├── opening_loc: (136...137) = "("
└── closing_loc: (138...139) = ")"
├── opening_loc: (23,6)-(23,7) = "("
└── 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: []
└── statements:
@ StatementsNode (location: (0...12))
@ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1)
└── @ PreExecutionNode (location: (0...12))
└── @ PreExecutionNode (location: (1,0)-(1,12))
├── statements:
│ @ StatementsNode (location: (8...10))
│ @ StatementsNode (location: (1,8)-(1,10))
│ └── body: (length: 1)
│ └── @ IntegerNode (location: (8...10))
│ └── @ IntegerNode (location: (1,8)-(1,10))
│ └── flags: decimal
├── keyword_loc: (0...5) = "BEGIN"
├── opening_loc: (6...7) = "{"
└── closing_loc: (11...12) = "}"
├── keyword_loc: (1,0)-(1,5) = "BEGIN"
├── opening_loc: (1,6)-(1,7) = "{"
└── 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: []
└── statements:
@ StatementsNode (location: (0...689))
@ StatementsNode (location: (1,0)-(92,1))
└── body: (length: 16)
├── @ ArrayNode (location: (0...7))
├── @ ArrayNode (location: (1,0)-(4,1))
│ ├── elements: (length: 0)
│ ├── opening_loc: (0...3) = "%I["
│ └── closing_loc: (6...7) = "]"
├── @ ArrayNode (location: (9...26))
│ ├── opening_loc: (1,0)-(1,3) = "%I["
│ └── closing_loc: (4,0)-(4,1) = "]"
├── @ ArrayNode (location: (6,0)-(9,1))
│ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (13...18))
│ │ ├── @ SymbolNode (location: (7,0)-(7,5))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (13...18) = "line2"
│ │ │ ├── value_loc: (7,0)-(7,5) = "line2"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (19...24))
│ │ └── @ SymbolNode (location: (8,0)-(8,5))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (19...24) = "line3"
│ │ ├── value_loc: (8,0)-(8,5) = "line3"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3"
│ ├── opening_loc: (9...12) = "%I["
│ └── closing_loc: (25...26) = "]"
├── @ ArrayNode (location: (28...35))
│ ├── opening_loc: (6,0)-(6,3) = "%I["
│ └── closing_loc: (9,0)-(9,1) = "]"
├── @ ArrayNode (location: (11,0)-(14,1))
│ ├── elements: (length: 0)
│ ├── opening_loc: (28...31) = "%W["
│ └── closing_loc: (34...35) = "]"
├── @ ArrayNode (location: (37...54))
│ ├── opening_loc: (11,0)-(11,3) = "%W["
│ └── closing_loc: (14,0)-(14,1) = "]"
├── @ ArrayNode (location: (16,0)-(19,1))
│ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (41...46))
│ │ ├── @ StringNode (location: (17,0)-(17,5))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (41...46) = "line2"
│ │ │ ├── content_loc: (17,0)-(17,5) = "line2"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2"
│ │ └── @ StringNode (location: (47...52))
│ │ └── @ StringNode (location: (18,0)-(18,5))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (47...52) = "line3"
│ │ ├── content_loc: (18,0)-(18,5) = "line3"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3"
│ ├── opening_loc: (37...40) = "%W["
│ └── closing_loc: (53...54) = "]"
├── @ ArrayNode (location: (56...63))
│ ├── opening_loc: (16,0)-(16,3) = "%W["
│ └── closing_loc: (19,0)-(19,1) = "]"
├── @ ArrayNode (location: (21,0)-(24,1))
│ ├── elements: (length: 0)
│ ├── opening_loc: (56...59) = "%i["
│ └── closing_loc: (62...63) = "]"
├── @ ArrayNode (location: (65...82))
│ ├── opening_loc: (21,0)-(21,3) = "%i["
│ └── closing_loc: (24,0)-(24,1) = "]"
├── @ ArrayNode (location: (26,0)-(29,1))
│ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (69...74))
│ │ ├── @ SymbolNode (location: (27,0)-(27,5))
│ │ │ ├── opening_loc: ∅
│ │ │ ├── value_loc: (69...74) = "line2"
│ │ │ ├── value_loc: (27,0)-(27,5) = "line2"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (75...80))
│ │ └── @ SymbolNode (location: (28,0)-(28,5))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (75...80) = "line3"
│ │ ├── value_loc: (28,0)-(28,5) = "line3"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3"
│ ├── opening_loc: (65...68) = "%i["
│ └── closing_loc: (81...82) = "]"
├── @ RegularExpressionNode (location: (84...91))
│ ├── opening_loc: (84...87) = "%r["
│ ├── content_loc: (87...90) = "\n\n\n"
│ ├── closing_loc: (90...91) = "]"
│ ├── opening_loc: (26,0)-(26,3) = "%i["
│ └── closing_loc: (29,0)-(29,1) = "]"
├── @ RegularExpressionNode (location: (31,0)-(34,1))
│ ├── opening_loc: (31,0)-(31,3) = "%r["
│ ├── content_loc: (31,3)-(33,0) = "\n\n\n"
│ ├── closing_loc: (34,0)-(34,1) = "]"
│ ├── unescaped: "\n\n\n"
│ └── flags: ∅
├── @ ArrayNode (location: (93...100))
├── @ ArrayNode (location: (36,0)-(39,1))
│ ├── elements: (length: 0)
│ ├── opening_loc: (93...96) = "%w["
│ └── closing_loc: (99...100) = "]"
├── @ ArrayNode (location: (102...119))
│ ├── opening_loc: (36,0)-(36,3) = "%w["
│ └── closing_loc: (39,0)-(39,1) = "]"
├── @ ArrayNode (location: (41,0)-(44,1))
│ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (106...111))
│ │ ├── @ StringNode (location: (42,0)-(42,5))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: ∅
│ │ │ ├── content_loc: (106...111) = "line2"
│ │ │ ├── content_loc: (42,0)-(42,5) = "line2"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2"
│ │ └── @ StringNode (location: (112...117))
│ │ └── @ StringNode (location: (43,0)-(43,5))
│ │ ├── flags: ∅
│ │ ├── opening_loc: ∅
│ │ ├── content_loc: (112...117) = "line3"
│ │ ├── content_loc: (43,0)-(43,5) = "line3"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3"
│ ├── opening_loc: (102...105) = "%w["
│ └── closing_loc: (118...119) = "]"
├── @ ArrayNode (location: (121...139))
│ ├── opening_loc: (41,0)-(41,3) = "%w["
│ └── closing_loc: (44,0)-(44,1) = "]"
├── @ ArrayNode (location: (46,0)-(49,1))
│ ├── elements: (length: 2)
│ │ ├── @ SymbolNode (location: (123...129))
│ │ │ ├── opening_loc: (123...124) = ":"
│ │ │ ├── value_loc: (124...129) = "line2"
│ │ ├── @ SymbolNode (location: (47,0)-(47,6))
│ │ │ ├── opening_loc: (47,0)-(47,1) = ":"
│ │ │ ├── value_loc: (47,1)-(47,6) = "line2"
│ │ │ ├── closing_loc: ∅
│ │ │ └── unescaped: "line2"
│ │ └── @ SymbolNode (location: (131...137))
│ │ ├── opening_loc: (131...132) = ":"
│ │ ├── value_loc: (132...137) = "line3"
│ │ └── @ SymbolNode (location: (48,0)-(48,6))
│ │ ├── opening_loc: (48,0)-(48,1) = ":"
│ │ ├── value_loc: (48,1)-(48,6) = "line3"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line3"
│ ├── opening_loc: (121...122) = "["
│ └── closing_loc: (138...139) = "]"
├── @ ClassNode (location: (141...269))
│ ├── opening_loc: (46,0)-(46,1) = "["
│ └── closing_loc: (49,0)-(49,1) = "]"
├── @ ClassNode (location: (51,0)-(56,3))
│ ├── locals: []
│ ├── class_keyword_loc: (141...146) = "class"
│ ├── class_keyword_loc: (51,0)-(51,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (147...148))
│ │ @ ConstantReadNode (location: (51,6)-(51,7))
│ │ └── name: :X
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (168...246))
│ │ @ StatementsNode (location: (52,2)-(55,5))
│ │ └── body: (length: 1)
│ │ └── @ DefNode (location: (168...246))
│ │ └── @ DefNode (location: (52,2)-(55,5))
│ │ ├── name: :y
│ │ ├── name_loc: (177...178) = "y"
│ │ ├── name_loc: (52,11)-(52,12) = "y"
│ │ ├── receiver:
│ │ │ @ SelfNode (location: (172...176))
│ │ │ @ SelfNode (location: (52,6)-(52,10))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (179...200))
│ │ │ @ ParametersNode (location: (52,13)-(53,9))
│ │ │ ├── requireds: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (179...180))
│ │ │ │ ├── @ RequiredParameterNode (location: (52,13)-(52,14))
│ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (199...200))
│ │ │ │ └── @ RequiredParameterNode (location: (53,8)-(53,9))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -129,20 +129,20 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (220...225))
│ │ │ @ StatementsNode (location: (54,4)-(54,9))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (220...225))
│ │ │ └── @ CallNode (location: (54,4)-(54,9))
│ │ │ ├── receiver:
│ │ │ │ @ LocalVariableReadNode (location: (220...221))
│ │ │ │ @ LocalVariableReadNode (location: (54,4)-(54,5))
│ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (222...223) = "+"
│ │ │ ├── message_loc: (54,6)-(54,7) = "+"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (224...225))
│ │ │ │ @ ArgumentsNode (location: (54,8)-(54,9))
│ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ LocalVariableReadNode (location: (224...225))
│ │ │ │ └── @ LocalVariableReadNode (location: (54,8)-(54,9))
│ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0
│ │ │ ├── closing_loc: ∅
@ -150,68 +150,68 @@
│ │ │ ├── flags: ∅
│ │ │ └── name: "+"
│ │ ├── locals: [:a, :b]
│ │ ├── def_keyword_loc: (168...171) = "def"
│ │ ├── operator_loc: (176...177) = "."
│ │ ├── lparen_loc: (178...179) = "("
│ │ ├── rparen_loc: (200...201) = ")"
│ │ ├── def_keyword_loc: (52,2)-(52,5) = "def"
│ │ ├── operator_loc: (52,10)-(52,11) = "."
│ │ ├── lparen_loc: (52,12)-(52,13) = "("
│ │ ├── rparen_loc: (53,9)-(53,10) = ")"
│ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (243...246) = "end"
│ ├── end_keyword_loc: (266...269) = "end"
│ │ └── end_keyword_loc: (55,2)-(55,5) = "end"
│ ├── end_keyword_loc: (56,0)-(56,3) = "end"
│ └── name: :X
├── @ ClassNode (location: (293...376))
├── @ ClassNode (location: (59,0)-(63,3))
│ ├── locals: []
│ ├── class_keyword_loc: (293...298) = "class"
│ ├── class_keyword_loc: (59,0)-(59,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (299...300))
│ │ @ ConstantReadNode (location: (59,6)-(59,7))
│ │ └── name: :X
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (315...358))
│ │ @ StatementsNode (location: (60,2)-(62,5))
│ │ └── body: (length: 1)
│ │ └── @ ClassNode (location: (315...358))
│ │ └── @ ClassNode (location: (60,2)-(62,5))
│ │ ├── locals: []
│ │ ├── class_keyword_loc: (315...320) = "class"
│ │ ├── class_keyword_loc: (60,2)-(60,7) = "class"
│ │ ├── constant_path:
│ │ │ @ ConstantReadNode (location: (321...322))
│ │ │ @ ConstantReadNode (location: (60,8)-(60,9))
│ │ │ └── name: :Y
│ │ ├── inheritance_operator_loc: ∅
│ │ ├── superclass: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (337...343))
│ │ │ @ StatementsNode (location: (61,4)-(61,10))
│ │ │ └── body: (length: 1)
│ │ │ └── @ ConstantWriteNode (location: (337...343))
│ │ │ └── @ ConstantWriteNode (location: (61,4)-(61,10))
│ │ │ ├── name: :Z
│ │ │ ├── name_loc: (337...338) = "Z"
│ │ │ ├── name_loc: (61,4)-(61,5) = "Z"
│ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (341...343))
│ │ │ │ @ IntegerNode (location: (61,8)-(61,10))
│ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (339...340) = "="
│ │ ├── end_keyword_loc: (355...358) = "end"
│ │ │ └── operator_loc: (61,6)-(61,7) = "="
│ │ ├── end_keyword_loc: (62,2)-(62,5) = "end"
│ │ └── name: :Y
│ ├── end_keyword_loc: (373...376) = "end"
│ ├── end_keyword_loc: (63,0)-(63,3) = "end"
│ └── name: :X
├── @ ClassNode (location: (395...498))
├── @ ClassNode (location: (66,0)-(71,3))
│ ├── locals: []
│ ├── class_keyword_loc: (395...400) = "class"
│ ├── class_keyword_loc: (66,0)-(66,5) = "class"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (401...402))
│ │ @ ConstantReadNode (location: (66,6)-(66,7))
│ │ └── name: :X
│ ├── inheritance_operator_loc: ∅
│ ├── superclass: ∅
│ ├── body:
│ │ @ StatementsNode (location: (417...480))
│ │ @ StatementsNode (location: (67,2)-(70,5))
│ │ └── body: (length: 1)
│ │ └── @ DefNode (location: (417...480))
│ │ └── @ DefNode (location: (67,2)-(70,5))
│ │ ├── name: :y
│ │ ├── name_loc: (421...422) = "y"
│ │ ├── name_loc: (67,6)-(67,7) = "y"
│ │ ├── receiver: ∅
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (423...444))
│ │ │ @ ParametersNode (location: (67,8)-(68,9))
│ │ │ ├── requireds: (length: 2)
│ │ │ │ ├── @ RequiredParameterNode (location: (423...424))
│ │ │ │ ├── @ RequiredParameterNode (location: (67,8)-(67,9))
│ │ │ │ │ └── name: :a
│ │ │ │ └── @ RequiredParameterNode (location: (443...444))
│ │ │ │ └── @ RequiredParameterNode (location: (68,8)-(68,9))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -220,20 +220,20 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (459...464))
│ │ │ @ StatementsNode (location: (69,4)-(69,9))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (459...464))
│ │ │ └── @ CallNode (location: (69,4)-(69,9))
│ │ │ ├── receiver:
│ │ │ │ @ LocalVariableReadNode (location: (459...460))
│ │ │ │ @ LocalVariableReadNode (location: (69,4)-(69,5))
│ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (461...462) = "+"
│ │ │ ├── message_loc: (69,6)-(69,7) = "+"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments:
│ │ │ │ @ ArgumentsNode (location: (463...464))
│ │ │ │ @ ArgumentsNode (location: (69,8)-(69,9))
│ │ │ │ └── arguments: (length: 1)
│ │ │ │ └── @ LocalVariableReadNode (location: (463...464))
│ │ │ │ └── @ LocalVariableReadNode (location: (69,8)-(69,9))
│ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0
│ │ │ ├── closing_loc: ∅
@ -241,92 +241,92 @@
│ │ │ ├── flags: ∅
│ │ │ └── name: "+"
│ │ ├── locals: [:a, :b]
│ │ ├── def_keyword_loc: (417...420) = "def"
│ │ ├── def_keyword_loc: (67,2)-(67,5) = "def"
│ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: (422...423) = "("
│ │ ├── rparen_loc: (444...445) = ")"
│ │ ├── lparen_loc: (67,7)-(67,8) = "("
│ │ ├── rparen_loc: (68,9)-(68,10) = ")"
│ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (477...480) = "end"
│ ├── end_keyword_loc: (495...498) = "end"
│ │ └── end_keyword_loc: (70,2)-(70,5) = "end"
│ ├── end_keyword_loc: (71,0)-(71,3) = "end"
│ └── name: :X
├── @ ModuleNode (location: (517...565))
├── @ ModuleNode (location: (74,0)-(79,3))
│ ├── locals: []
│ ├── module_keyword_loc: (517...523) = "module"
│ ├── module_keyword_loc: (74,0)-(74,6) = "module"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (524...525))
│ │ @ ConstantReadNode (location: (74,7)-(74,8))
│ │ └── name: :X
│ ├── body:
│ │ @ StatementsNode (location: (528...561))
│ │ @ StatementsNode (location: (75,2)-(78,3))
│ │ └── body: (length: 1)
│ │ └── @ ConstantWriteNode (location: (528...561))
│ │ └── @ ConstantWriteNode (location: (75,2)-(78,3))
│ │ ├── name: :X
│ │ ├── name_loc: (528...529) = "X"
│ │ ├── name_loc: (75,2)-(75,3) = "X"
│ │ ├── value:
│ │ │ @ ArrayNode (location: (532...561))
│ │ │ @ ArrayNode (location: (75,6)-(78,3))
│ │ │ ├── elements: (length: 2)
│ │ │ │ ├── @ SymbolNode (location: (538...544))
│ │ │ │ │ ├── opening_loc: (538...539) = ":"
│ │ │ │ │ ├── value_loc: (539...544) = "line3"
│ │ │ │ ├── @ SymbolNode (location: (76,4)-(76,10))
│ │ │ │ │ ├── opening_loc: (76,4)-(76,5) = ":"
│ │ │ │ │ ├── value_loc: (76,5)-(76,10) = "line3"
│ │ │ │ │ ├── closing_loc: ∅
│ │ │ │ │ └── unescaped: "line3"
│ │ │ │ └── @ SymbolNode (location: (550...556))
│ │ │ │ ├── opening_loc: (550...551) = ":"
│ │ │ │ ├── value_loc: (551...556) = "line4"
│ │ │ │ └── @ SymbolNode (location: (77,4)-(77,10))
│ │ │ │ ├── opening_loc: (77,4)-(77,5) = ":"
│ │ │ │ ├── value_loc: (77,5)-(77,10) = "line4"
│ │ │ │ ├── closing_loc: ∅
│ │ │ │ └── unescaped: "line4"
│ │ │ ├── opening_loc: (532...533) = "["
│ │ │ └── closing_loc: (560...561) = "]"
│ │ └── operator_loc: (530...531) = "="
│ ├── end_keyword_loc: (562...565) = "end"
│ │ │ ├── opening_loc: (75,6)-(75,7) = "["
│ │ │ └── closing_loc: (78,2)-(78,3) = "]"
│ │ └── operator_loc: (75,4)-(75,5) = "="
│ ├── end_keyword_loc: (79,0)-(79,3) = "end"
│ └── name: :X
├── @ ModuleNode (location: (568...651))
├── @ ModuleNode (location: (82,0)-(86,3))
│ ├── locals: []
│ ├── module_keyword_loc: (568...574) = "module"
│ ├── module_keyword_loc: (82,0)-(82,6) = "module"
│ ├── constant_path:
│ │ @ ConstantReadNode (location: (575...576))
│ │ @ ConstantReadNode (location: (82,7)-(82,8))
│ │ └── name: :X
│ ├── body:
│ │ @ StatementsNode (location: (590...633))
│ │ @ StatementsNode (location: (83,2)-(85,5))
│ │ └── body: (length: 1)
│ │ └── @ ModuleNode (location: (590...633))
│ │ └── @ ModuleNode (location: (83,2)-(85,5))
│ │ ├── locals: []
│ │ ├── module_keyword_loc: (590...596) = "module"
│ │ ├── module_keyword_loc: (83,2)-(83,8) = "module"
│ │ ├── constant_path:
│ │ │ @ ConstantReadNode (location: (597...598))
│ │ │ @ ConstantReadNode (location: (83,9)-(83,10))
│ │ │ └── name: :Y
│ │ ├── body:
│ │ │ @ StatementsNode (location: (612...618))
│ │ │ @ StatementsNode (location: (84,4)-(84,10))
│ │ │ └── body: (length: 1)
│ │ │ └── @ ConstantWriteNode (location: (612...618))
│ │ │ └── @ ConstantWriteNode (location: (84,4)-(84,10))
│ │ │ ├── name: :Z
│ │ │ ├── name_loc: (612...613) = "Z"
│ │ │ ├── name_loc: (84,4)-(84,5) = "Z"
│ │ │ ├── value:
│ │ │ │ @ IntegerNode (location: (616...618))
│ │ │ │ @ IntegerNode (location: (84,8)-(84,10))
│ │ │ │ └── flags: decimal
│ │ │ └── operator_loc: (614...615) = "="
│ │ ├── end_keyword_loc: (630...633) = "end"
│ │ │ └── operator_loc: (84,6)-(84,7) = "="
│ │ ├── end_keyword_loc: (85,2)-(85,5) = "end"
│ │ └── name: :Y
│ ├── end_keyword_loc: (648...651) = "end"
│ ├── end_keyword_loc: (86,0)-(86,3) = "end"
│ └── name: :X
└── @ CallNode (location: (670...689))
└── @ CallNode (location: (89,0)-(92,1))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (670...671) = "x"
├── opening_loc: (671...672) = "("
├── message_loc: (89,0)-(89,1) = "x"
├── opening_loc: (89,1)-(89,2) = "("
├── arguments:
│ @ ArgumentsNode (location: (673...687))
│ @ ArgumentsNode (location: (90,0)-(91,6))
│ └── arguments: (length: 2)
│ ├── @ SymbolNode (location: (673...679))
│ │ ├── opening_loc: (673...674) = ":"
│ │ ├── value_loc: (674...679) = "line2"
│ ├── @ SymbolNode (location: (90,0)-(90,6))
│ │ ├── opening_loc: (90,0)-(90,1) = ":"
│ │ ├── value_loc: (90,1)-(90,6) = "line2"
│ │ ├── closing_loc: ∅
│ │ └── unescaped: "line2"
│ └── @ SymbolNode (location: (681...687))
│ ├── opening_loc: (681...682) = ":"
│ ├── value_loc: (682...687) = "line3"
│ └── @ SymbolNode (location: (91,0)-(91,6))
│ ├── opening_loc: (91,0)-(91,1) = ":"
│ ├── value_loc: (91,1)-(91,6) = "line3"
│ ├── closing_loc: ∅
│ └── unescaped: "line3"
├── closing_loc: (688...689) = ")"
├── closing_loc: (92,0)-(92,1) = ")"
├── block: ∅
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...12))
@ StatementsNode (location: (1,0)-(1,12))
└── 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: []
└── statements:
@ StatementsNode (location: (0...15))
@ StatementsNode (location: (1,0)-(1,15))
└── body: (length: 1)
└── @ AliasGlobalVariableNode (location: (0...15))
└── @ AliasGlobalVariableNode (location: (1,0)-(1,15))
├── new_name:
│ @ GlobalVariableReadNode (location: (6...12))
│ @ GlobalVariableReadNode (location: (1,6)-(1,12))
│ └── name: :$MATCH
├── old_name:
│ @ BackReferenceReadNode (location: (13...15))
└── keyword_loc: (0...5) = "alias"
│ @ BackReferenceReadNode (location: (1,13)-(1,15))
└── 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: []
└── statements:
@ StatementsNode (location: (0...12))
@ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1)
└── @ AliasMethodNode (location: (0...12))
└── @ AliasMethodNode (location: (1,0)-(1,12))
├── new_name:
│ @ SymbolNode (location: (6...8))
│ @ SymbolNode (location: (1,6)-(1,8))
│ ├── opening_loc: ∅
│ ├── value_loc: (6...8) = "in"
│ ├── value_loc: (1,6)-(1,8) = "in"
│ ├── closing_loc: ∅
│ └── unescaped: "in"
├── old_name:
│ @ SymbolNode (location: (9...12))
│ @ SymbolNode (location: (1,9)-(1,12))
│ ├── opening_loc: ∅
│ ├── value_loc: (9...12) = "out"
│ ├── value_loc: (1,9)-(1,12) = "out"
│ ├── closing_loc: ∅
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...27))
@ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 1)
└── @ AndNode (location: (0...27))
└── @ AndNode (location: (1,0)-(3,4))
├── left:
│ @ AndNode (location: (0...18))
│ @ AndNode (location: (1,0)-(2,9))
│ ├── left:
│ │ @ TrueNode (location: (0...4))
│ │ @ TrueNode (location: (1,0)-(1,4))
│ ├── right:
│ │ @ CallNode (location: (9...18))
│ │ @ CallNode (location: (2,0)-(2,9))
│ │ ├── receiver:
│ │ │ @ FalseNode (location: (13...18))
│ │ │ @ FalseNode (location: (2,4)-(2,9))
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (9...12) = "not"
│ │ ├── message_loc: (2,0)-(2,3) = "not"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "!"
│ └── operator_loc: (5...8) = "and"
│ └── operator_loc: (1,5)-(1,8) = "and"
├── right:
│ @ TrueNode (location: (23...27))
└── operator_loc: (19...22) = "and"
│ @ TrueNode (location: (3,0)-(3,4))
└── 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: []
└── statements:
@ StatementsNode (location: (0...8))
@ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1)
└── @ ArrayNode (location: (0...8))
└── @ ArrayNode (location: (1,0)-(1,8))
├── elements: (length: 1)
│ └── @ KeywordHashNode (location: (1...7))
│ └── @ KeywordHashNode (location: (1,1)-(1,7))
│ └── elements: (length: 1)
│ └── @ AssocNode (location: (1...7))
│ └── @ AssocNode (location: (1,1)-(1,7))
│ ├── key:
│ │ @ IntegerNode (location: (1...2))
│ │ @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal
│ ├── value:
│ │ @ IntegerNode (location: (6...7))
│ │ @ IntegerNode (location: (1,6)-(1,7))
│ │ └── flags: decimal
│ └── operator_loc: (3...5) = "=>"
├── opening_loc: (0...1) = "["
└── closing_loc: (7...8) = "]"
│ └── operator_loc: (1,3)-(1,5) = "=>"
├── opening_loc: (1,0)-(1,1) = "["
└── 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: []
└── statements:
@ StatementsNode (location: (0...11))
@ StatementsNode (location: (1,0)-(1,11))
└── body: (length: 1)
└── @ ArrayNode (location: (0...11))
└── @ ArrayNode (location: (1,0)-(1,11))
├── elements: (length: 2)
│ ├── @ IntegerNode (location: (1...2))
│ ├── @ IntegerNode (location: (1,1)-(1,2))
│ │ └── flags: decimal
│ └── @ KeywordHashNode (location: (4...10))
│ └── @ KeywordHashNode (location: (1,4)-(1,10))
│ └── elements: (length: 1)
│ └── @ AssocNode (location: (4...10))
│ └── @ AssocNode (location: (1,4)-(1,10))
│ ├── key:
│ │ @ IntegerNode (location: (4...5))
│ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ └── flags: decimal
│ ├── value:
│ │ @ IntegerNode (location: (9...10))
│ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal
│ └── operator_loc: (6...8) = "=>"
├── opening_loc: (0...1) = "["
└── closing_loc: (10...11) = "]"
│ └── operator_loc: (1,6)-(1,8) = "=>"
├── opening_loc: (1,0)-(1,1) = "["
└── 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: []
└── statements:
@ StatementsNode (location: (0...20))
@ StatementsNode (location: (1,0)-(1,20))
└── body: (length: 1)
└── @ DefNode (location: (0...20))
└── @ DefNode (location: (1,0)-(1,20))
├── name: :f
├── name_loc: (4...5) = "f"
├── name_loc: (1,4)-(1,5) = "f"
├── receiver: ∅
├── parameters:
│ @ ParametersNode (location: (6...14))
│ @ ParametersNode (location: (1,6)-(1,14))
│ ├── requireds: (length: 0)
│ ├── optionals: (length: 0)
│ ├── rest: ∅
│ ├── posts: (length: 0)
│ ├── keywords: (length: 1)
│ │ └── @ KeywordParameterNode (location: (6...10))
│ │ └── @ KeywordParameterNode (location: (1,6)-(1,10))
│ │ ├── name: :a
│ │ ├── name_loc: (6...8) = "a:"
│ │ ├── name_loc: (1,6)-(1,8) = "a:"
│ │ └── value:
│ │ @ IntegerNode (location: (9...10))
│ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ └── flags: decimal
│ ├── keyword_rest: ∅
│ └── block:
│ @ BlockParameterNode (location: (12...14))
│ @ BlockParameterNode (location: (1,12)-(1,14))
│ ├── name: :b
│ ├── name_loc: (13...14) = "b"
│ └── operator_loc: (12...13) = "&"
│ ├── name_loc: (1,13)-(1,14) = "b"
│ └── operator_loc: (1,12)-(1,13) = "&"
├── body: ∅
├── locals: [:a, :b]
├── def_keyword_loc: (0...3) = "def"
├── def_keyword_loc: (1,0)-(1,3) = "def"
├── operator_loc: ∅
├── lparen_loc: (5...6) = "("
├── rparen_loc: (14...15) = ")"
├── lparen_loc: (1,5)-(1,6) = "("
├── rparen_loc: (1,14)-(1,15) = ")"
├── 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: []
└── statements:
@ StatementsNode (location: (0...13))
@ StatementsNode (location: (1,0)-(4,1))
└── body: (length: 2)
├── @ ArrayNode (location: (0...11))
├── @ ArrayNode (location: (1,0)-(3,4))
│ ├── elements: (length: 2)
│ │ ├── @ StringNode (location: (2...5))
│ │ ├── @ StringNode (location: (2,0)-(2,3))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (2...3) = "'"
│ │ │ ├── content_loc: (3...4) = "a"
│ │ │ ├── closing_loc: (4...5) = "'"
│ │ │ ├── opening_loc: (2,0)-(2,1) = "'"
│ │ │ ├── content_loc: (2,1)-(2,2) = "a"
│ │ │ ├── closing_loc: (2,2)-(2,3) = "'"
│ │ │ └── unescaped: "a"
│ │ └── @ StringNode (location: (7...10))
│ │ └── @ StringNode (location: (3,0)-(3,3))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (7...8) = "'"
│ │ ├── content_loc: (8...9) = "b"
│ │ ├── closing_loc: (9...10) = "'"
│ │ ├── opening_loc: (3,0)-(3,1) = "'"
│ │ ├── content_loc: (3,1)-(3,2) = "b"
│ │ ├── closing_loc: (3,2)-(3,3) = "'"
│ │ └── unescaped: "b"
│ ├── opening_loc: (0...1) = "["
│ └── closing_loc: (10...11) = "]"
└── @ IntegerNode (location: (12...13))
│ ├── opening_loc: (1,0)-(1,1) = "["
│ └── closing_loc: (3,3)-(3,4) = "]"
└── @ IntegerNode (location: (4,0)-(4,1))
└── 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: []
└── statements:
@ StatementsNode (location: (0...12))
@ StatementsNode (location: (1,0)-(3,4))
└── body: (length: 2)
├── @ CallNode (location: (0...6))
├── @ CallNode (location: (1,0)-(1,6))
│ ├── receiver:
│ │ @ ArrayNode (location: (0...4))
│ │ @ ArrayNode (location: (1,0)-(1,4))
│ │ ├── elements: (length: 0)
│ │ ├── opening_loc: (0...3) = "%w["
│ │ └── closing_loc: (3...4) = "]"
│ ├── call_operator_loc: (4...5) = "."
│ ├── message_loc: (5...6) = "b"
│ │ ├── opening_loc: (1,0)-(1,3) = "%w["
│ │ └── closing_loc: (1,3)-(1,4) = "]"
│ ├── call_operator_loc: (1,4)-(1,5) = "."
│ ├── message_loc: (1,5)-(1,6) = "b"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "b"
└── @ CallNode (location: (8...12))
└── @ CallNode (location: (3,0)-(3,4))
├── receiver:
│ @ ArrayNode (location: (8...10))
│ @ ArrayNode (location: (3,0)-(3,2))
│ ├── elements: (length: 0)
│ ├── opening_loc: (8...9) = "["
│ └── closing_loc: (9...10) = "]"
├── call_operator_loc: (10...11) = "."
├── message_loc: (11...12) = "b"
│ ├── opening_loc: (3,0)-(3,1) = "["
│ └── closing_loc: (3,1)-(3,2) = "]"
├── call_operator_loc: (3,2)-(3,3) = "."
├── message_loc: (3,3)-(3,4) = "b"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...6))
@ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1)
└── @ HashNode (location: (0...6))
├── opening_loc: (0...1) = "{"
└── @ HashNode (location: (1,0)-(1,6))
├── opening_loc: (1,0)-(1,1) = "{"
├── elements: (length: 1)
│ └── @ AssocNode (location: (2...4))
│ └── @ AssocNode (location: (1,2)-(1,4))
│ ├── key:
│ │ @ SymbolNode (location: (2...4))
│ │ @ SymbolNode (location: (1,2)-(1,4))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (2...3) = "y"
│ │ ├── closing_loc: (3...4) = ":"
│ │ ├── value_loc: (1,2)-(1,3) = "y"
│ │ ├── closing_loc: (1,3)-(1,4) = ":"
│ │ └── unescaped: "y"
│ ├── value:
│ │ @ ImplicitNode (location: (2...4))
│ │ @ ImplicitNode (location: (1,2)-(1,4))
│ │ └── value:
│ │ @ CallNode (location: (2...4))
│ │ @ CallNode (location: (1,2)-(1,4))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (2...3) = "y"
│ │ ├── message_loc: (1,2)-(1,3) = "y"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -27,4 +27,4 @@
│ │ ├── flags: ∅
│ │ └── name: "y"
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...6))
@ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1)
└── @ CallNode (location: (0...6))
└── @ CallNode (location: (1,0)-(1,6))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── opening_loc: (1...2) = "("
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: (1,1)-(1,2) = "("
├── arguments:
│ @ ArgumentsNode (location: (2...5))
│ @ ArgumentsNode (location: (1,2)-(1,5))
│ └── arguments: (length: 1)
│ └── @ KeywordHashNode (location: (2...5))
│ └── @ KeywordHashNode (location: (1,2)-(1,5))
│ └── elements: (length: 1)
│ └── @ AssocNode (location: (2...5))
│ └── @ AssocNode (location: (1,2)-(1,5))
│ ├── key:
│ │ @ SymbolNode (location: (2...4))
│ │ @ SymbolNode (location: (1,2)-(1,4))
│ │ ├── opening_loc: ∅
│ │ ├── value_loc: (2...3) = "b"
│ │ ├── closing_loc: (3...4) = ":"
│ │ ├── value_loc: (1,2)-(1,3) = "b"
│ │ ├── closing_loc: (1,3)-(1,4) = ":"
│ │ └── unescaped: "b"
│ ├── value:
│ │ @ IntegerNode (location: (4...5))
│ │ @ IntegerNode (location: (1,4)-(1,5))
│ │ └── flags: decimal
│ └── operator_loc: ∅
├── closing_loc: (5...6) = ")"
├── closing_loc: (1,5)-(1,6) = ")"
├── block: ∅
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...8))
@ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1)
└── @ CallNode (location: (0...8))
└── @ CallNode (location: (1,0)-(1,8))
├── receiver:
│ @ ConstantReadNode (location: (0...1))
│ @ ConstantReadNode (location: (1,0)-(1,1))
│ └── name: :A
├── call_operator_loc: (1...3) = "::"
├── message_loc: (3...4) = "b"
├── call_operator_loc: (1,1)-(1,3) = "::"
├── message_loc: (1,3)-(1,4) = "b"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (7...8))
│ @ ArgumentsNode (location: (1,7)-(1,8))
│ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (7...8))
│ └── @ IntegerNode (location: (1,7)-(1,8))
│ └── flags: decimal
├── closing_loc: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...13))
@ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1)
└── @ CallNode (location: (0...13))
└── @ CallNode (location: (1,0)-(1,13))
├── receiver:
│ @ CallNode (location: (0...1))
│ @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a"
│ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
@ -16,22 +16,22 @@
│ ├── flags: variable_call
│ └── name: "a"
├── call_operator_loc: ∅
├── message_loc: (1...9) = "[[1, 2]]"
├── opening_loc: (1...2) = "["
├── message_loc: (1,1)-(1,9) = "[[1, 2]]"
├── opening_loc: (1,1)-(1,2) = "["
├── arguments:
│ @ ArgumentsNode (location: (2...13))
│ @ ArgumentsNode (location: (1,2)-(1,13))
│ └── arguments: (length: 2)
│ ├── @ ArrayNode (location: (2...8))
│ ├── @ ArrayNode (location: (1,2)-(1,8))
│ │ ├── elements: (length: 2)
│ │ │ ├── @ IntegerNode (location: (3...4))
│ │ │ ├── @ IntegerNode (location: (1,3)-(1,4))
│ │ │ │ └── flags: decimal
│ │ │ └── @ IntegerNode (location: (6...7))
│ │ │ └── @ IntegerNode (location: (1,6)-(1,7))
│ │ │ └── flags: decimal
│ │ ├── opening_loc: (2...3) = "["
│ │ └── closing_loc: (7...8) = "]"
│ └── @ IntegerNode (location: (12...13))
│ │ ├── opening_loc: (1,2)-(1,3) = "["
│ │ └── closing_loc: (1,7)-(1,8) = "]"
│ └── @ IntegerNode (location: (1,12)-(1,13))
│ └── flags: decimal
├── closing_loc: (8...9) = "]"
├── closing_loc: (1,8)-(1,9) = "]"
├── block: ∅
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...42))
@ StatementsNode (location: (1,0)-(1,42))
└── body: (length: 1)
└── @ CallNode (location: (0...42))
└── @ CallNode (location: (1,0)-(1,42))
├── receiver:
│ @ ArrayNode (location: (0...12))
│ @ ArrayNode (location: (1,0)-(1,12))
│ ├── elements: (length: 4)
│ │ ├── @ IntegerNode (location: (1...2))
│ │ ├── @ IntegerNode (location: (1,1)-(1,2))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (4...5))
│ │ ├── @ IntegerNode (location: (1,4)-(1,5))
│ │ │ └── flags: decimal
│ │ ├── @ IntegerNode (location: (7...8))
│ │ ├── @ IntegerNode (location: (1,7)-(1,8))
│ │ │ └── flags: decimal
│ │ └── @ IntegerNode (location: (10...11))
│ │ └── @ IntegerNode (location: (1,10)-(1,11))
│ │ └── flags: decimal
│ ├── opening_loc: (0...1) = "["
│ └── closing_loc: (11...12) = "]"
│ ├── opening_loc: (1,0)-(1,1) = "["
│ └── closing_loc: (1,11)-(1,12) = "]"
├── call_operator_loc: ∅
├── message_loc: (12...24) = "[from .. to]"
├── opening_loc: (12...13) = "["
├── message_loc: (1,12)-(1,24) = "[from .. to]"
├── opening_loc: (1,12)-(1,13) = "["
├── arguments:
│ @ ArgumentsNode (location: (13...42))
│ @ ArgumentsNode (location: (1,13)-(1,42))
│ └── arguments: (length: 2)
│ ├── @ RangeNode (location: (13...23))
│ ├── @ RangeNode (location: (1,13)-(1,23))
│ │ ├── left:
│ │ │ @ CallNode (location: (13...17))
│ │ │ @ CallNode (location: (1,13)-(1,17))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (13...17) = "from"
│ │ │ ├── message_loc: (1,13)-(1,17) = "from"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -36,41 +36,41 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "from"
│ │ ├── right:
│ │ │ @ CallNode (location: (21...23))
│ │ │ @ CallNode (location: (1,21)-(1,23))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (21...23) = "to"
│ │ │ ├── message_loc: (1,21)-(1,23) = "to"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "to"
│ │ ├── operator_loc: (18...20) = ".."
│ │ ├── operator_loc: (1,18)-(1,20) = ".."
│ │ └── flags: ∅
│ └── @ ArrayNode (location: (27...42))
│ └── @ ArrayNode (location: (1,27)-(1,42))
│ ├── elements: (length: 3)
│ │ ├── @ StringNode (location: (28...31))
│ │ ├── @ StringNode (location: (1,28)-(1,31))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (28...29) = "\""
│ │ │ ├── content_loc: (29...30) = "a"
│ │ │ ├── closing_loc: (30...31) = "\""
│ │ │ ├── opening_loc: (1,28)-(1,29) = "\""
│ │ │ ├── content_loc: (1,29)-(1,30) = "a"
│ │ │ ├── closing_loc: (1,30)-(1,31) = "\""
│ │ │ └── unescaped: "a"
│ │ ├── @ StringNode (location: (33...36))
│ │ ├── @ StringNode (location: (1,33)-(1,36))
│ │ │ ├── flags: ∅
│ │ │ ├── opening_loc: (33...34) = "\""
│ │ │ ├── content_loc: (34...35) = "b"
│ │ │ ├── closing_loc: (35...36) = "\""
│ │ │ ├── opening_loc: (1,33)-(1,34) = "\""
│ │ │ ├── content_loc: (1,34)-(1,35) = "b"
│ │ │ ├── closing_loc: (1,35)-(1,36) = "\""
│ │ │ └── unescaped: "b"
│ │ └── @ StringNode (location: (38...41))
│ │ └── @ StringNode (location: (1,38)-(1,41))
│ │ ├── flags: ∅
│ │ ├── opening_loc: (38...39) = "\""
│ │ ├── content_loc: (39...40) = "c"
│ │ ├── closing_loc: (40...41) = "\""
│ │ ├── opening_loc: (1,38)-(1,39) = "\""
│ │ ├── content_loc: (1,39)-(1,40) = "c"
│ │ ├── closing_loc: (1,40)-(1,41) = "\""
│ │ └── unescaped: "c"
│ ├── opening_loc: (27...28) = "["
│ └── closing_loc: (41...42) = "]"
├── closing_loc: (23...24) = "]"
│ ├── opening_loc: (1,27)-(1,28) = "["
│ └── closing_loc: (1,41)-(1,42) = "]"
├── closing_loc: (1,23)-(1,24) = "]"
├── block: ∅
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...7))
@ StatementsNode (location: (1,0)-(1,7))
└── body: (length: 1)
└── @ CallNode (location: (0...7))
└── @ CallNode (location: (1,0)-(1,7))
├── receiver:
│ @ CallNode (location: (0...1))
│ @ CallNode (location: (1,0)-(1,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a"
│ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "a"
├── call_operator_loc: (1...2) = "."
├── message_loc: (2...3) = "B"
├── call_operator_loc: (1,1)-(1,2) = "."
├── message_loc: (1,2)-(1,3) = "B"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (6...7))
│ @ ArgumentsNode (location: (1,6)-(1,7))
│ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (6...7))
│ └── @ IntegerNode (location: (1,6)-(1,7))
│ └── flags: decimal
├── closing_loc: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...8))
@ StatementsNode (location: (1,0)-(1,8))
└── body: (length: 1)
└── @ CallNode (location: (0...8))
└── @ CallNode (location: (1,0)-(1,8))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "x"
├── message_loc: (1,0)-(1,1) = "x"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (2...8))
│ @ ArgumentsNode (location: (1,2)-(1,8))
│ └── arguments: (length: 1)
│ └── @ InterpolatedXStringNode (location: (2...8))
│ ├── opening_loc: (2...3) = "`"
│ └── @ InterpolatedXStringNode (location: (1,2)-(1,8))
│ ├── opening_loc: (1,2)-(1,3) = "`"
│ ├── parts: (length: 1)
│ │ └── @ EmbeddedStatementsNode (location: (3...7))
│ │ ├── opening_loc: (3...5) = "\#{"
│ │ └── @ EmbeddedStatementsNode (location: (1,3)-(1,7))
│ │ ├── opening_loc: (1,3)-(1,5) = "\#{"
│ │ ├── statements:
│ │ │ @ StatementsNode (location: (5...6))
│ │ │ @ StatementsNode (location: (1,5)-(1,6))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (5...6))
│ │ │ └── @ CallNode (location: (1,5)-(1,6))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (5...6) = "y"
│ │ │ ├── message_loc: (1,5)-(1,6) = "y"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "y"
│ │ └── closing_loc: (6...7) = "}"
│ └── closing_loc: (7...8) = "`"
│ │ └── closing_loc: (1,6)-(1,7) = "}"
│ └── closing_loc: (1,7)-(1,8) = "`"
├── closing_loc: ∅
├── block: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...6))
@ StatementsNode (location: (1,0)-(1,6))
└── body: (length: 1)
└── @ CallNode (location: (0...6))
└── @ CallNode (location: (1,0)-(1,6))
├── receiver:
│ @ IntegerNode (location: (0...1))
│ @ IntegerNode (location: (1,0)-(1,1))
│ └── flags: decimal
├── call_operator_loc: ∅
├── message_loc: (2...4) = "!="
├── message_loc: (1,2)-(1,4) = "!="
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (5...6))
│ @ ArgumentsNode (location: (1,5)-(1,6))
│ └── arguments: (length: 1)
│ └── @ IntegerNode (location: (5...6))
│ └── @ IntegerNode (location: (1,5)-(1,6))
│ └── flags: decimal
├── closing_loc: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...14))
@ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 3)
├── @ RangeNode (location: (0...4))
├── @ RangeNode (location: (1,0)-(1,4))
│ ├── left: ∅
│ ├── right:
│ │ @ IntegerNode (location: (2...4))
│ │ @ IntegerNode (location: (1,2)-(1,4))
│ │ └── flags: decimal
│ ├── operator_loc: (0...2) = ".."
│ ├── operator_loc: (1,0)-(1,2) = ".."
│ └── flags: ∅
├── @ RangeNode (location: (7...10))
├── @ RangeNode (location: (2,2)-(2,5))
│ ├── left: ∅
│ ├── right:
│ │ @ CallNode (location: (9...10))
│ │ @ CallNode (location: (2,4)-(2,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (9...10) = "a"
│ │ ├── message_loc: (2,4)-(2,5) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── operator_loc: (7...9) = ".."
│ ├── operator_loc: (2,2)-(2,4) = ".."
│ └── flags: ∅
└── @ CallNode (location: (13...14))
└── @ CallNode (location: (3,2)-(3,3))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (13...14) = "c"
├── message_loc: (3,2)-(3,3) = "c"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...16))
@ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 3)
├── @ RangeNode (location: (0...5))
├── @ RangeNode (location: (1,0)-(1,5))
│ ├── left: ∅
│ ├── right:
│ │ @ IntegerNode (location: (3...5))
│ │ @ IntegerNode (location: (1,3)-(1,5))
│ │ └── flags: decimal
│ ├── operator_loc: (0...3) = "..."
│ ├── operator_loc: (1,0)-(1,3) = "..."
│ └── flags: exclude_end
├── @ RangeNode (location: (8...12))
├── @ RangeNode (location: (2,2)-(2,6))
│ ├── left: ∅
│ ├── right:
│ │ @ CallNode (location: (11...12))
│ │ @ CallNode (location: (2,5)-(2,6))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (11...12) = "a"
│ │ ├── message_loc: (2,5)-(2,6) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── operator_loc: (8...11) = "..."
│ ├── operator_loc: (2,2)-(2,5) = "..."
│ └── flags: exclude_end
└── @ CallNode (location: (15...16))
└── @ CallNode (location: (3,2)-(3,3))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (15...16) = "c"
├── message_loc: (3,2)-(3,3) = "c"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...16))
@ StatementsNode (location: (1,0)-(3,3))
└── body: (length: 1)
└── @ BeginNode (location: (0...16))
├── begin_keyword_loc: (0...5) = "begin"
└── @ BeginNode (location: (1,0)-(3,3))
├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅
├── rescue_clause: ∅
├── else_clause: ∅
├── ensure_clause:
│ @ EnsureNode (location: (6...16))
│ ├── ensure_keyword_loc: (6...12) = "ensure"
│ @ EnsureNode (location: (2,0)-(3,3))
│ ├── ensure_keyword_loc: (2,0)-(2,6) = "ensure"
│ ├── statements: ∅
│ └── end_keyword_loc: (13...16) = "end"
└── end_keyword_loc: (13...16) = "end"
│ └── end_keyword_loc: (3,0)-(3,3) = "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: []
└── statements:
@ StatementsNode (location: (0...44))
@ StatementsNode (location: (1,0)-(9,3))
└── body: (length: 1)
└── @ BeginNode (location: (0...44))
├── begin_keyword_loc: (0...5) = "begin"
└── @ BeginNode (location: (1,0)-(9,3))
├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements:
│ @ StatementsNode (location: (8...9))
│ @ StatementsNode (location: (2,2)-(2,3))
│ └── body: (length: 1)
│ └── @ IntegerNode (location: (8...9))
│ └── @ IntegerNode (location: (2,2)-(2,3))
│ └── flags: decimal
├── rescue_clause:
│ @ RescueNode (location: (10...20))
│ ├── keyword_loc: (10...16) = "rescue"
│ @ RescueNode (location: (3,0)-(4,3))
│ ├── keyword_loc: (3,0)-(3,6) = "rescue"
│ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅
│ ├── reference: ∅
│ ├── statements:
│ │ @ StatementsNode (location: (19...20))
│ │ @ StatementsNode (location: (4,2)-(4,3))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (19...20))
│ │ └── @ IntegerNode (location: (4,2)-(4,3))
│ │ └── flags: decimal
│ └── consequent: ∅
├── else_clause:
│ @ ElseNode (location: (21...36))
│ ├── else_keyword_loc: (21...25) = "else"
│ @ ElseNode (location: (5,0)-(7,6))
│ ├── else_keyword_loc: (5,0)-(5,4) = "else"
│ ├── statements:
│ │ @ StatementsNode (location: (28...29))
│ │ @ StatementsNode (location: (6,2)-(6,3))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (28...29))
│ │ └── @ IntegerNode (location: (6,2)-(6,3))
│ │ └── flags: decimal
│ └── end_keyword_loc: (30...36) = "ensure"
│ └── end_keyword_loc: (7,0)-(7,6) = "ensure"
├── ensure_clause:
│ @ EnsureNode (location: (30...44))
│ ├── ensure_keyword_loc: (30...36) = "ensure"
│ @ EnsureNode (location: (7,0)-(9,3))
│ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
│ ├── statements:
│ │ @ StatementsNode (location: (39...40))
│ │ @ StatementsNode (location: (8,2)-(8,3))
│ │ └── body: (length: 1)
│ │ └── @ IntegerNode (location: (39...40))
│ │ └── @ IntegerNode (location: (8,2)-(8,3))
│ │ └── flags: decimal
│ └── end_keyword_loc: (41...44) = "end"
└── end_keyword_loc: (41...44) = "end"
│ └── end_keyword_loc: (9,0)-(9,3) = "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: []
└── statements:
@ StatementsNode (location: (0...32))
@ StatementsNode (location: (1,0)-(9,3))
└── body: (length: 1)
└── @ BeginNode (location: (0...32))
├── begin_keyword_loc: (0...5) = "begin"
└── @ BeginNode (location: (1,0)-(9,3))
├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅
├── rescue_clause:
│ @ RescueNode (location: (7...13))
│ ├── keyword_loc: (7...13) = "rescue"
│ @ RescueNode (location: (3,0)-(3,6))
│ ├── keyword_loc: (3,0)-(3,6) = "rescue"
│ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅
│ ├── reference: ∅
│ ├── statements: ∅
│ └── consequent: ∅
├── else_clause:
│ @ ElseNode (location: (15...27))
│ ├── else_keyword_loc: (15...19) = "else"
│ @ ElseNode (location: (5,0)-(7,6))
│ ├── else_keyword_loc: (5,0)-(5,4) = "else"
│ ├── statements: ∅
│ └── end_keyword_loc: (21...27) = "ensure"
│ └── end_keyword_loc: (7,0)-(7,6) = "ensure"
├── ensure_clause:
│ @ EnsureNode (location: (21...32))
│ ├── ensure_keyword_loc: (21...27) = "ensure"
│ @ EnsureNode (location: (7,0)-(9,3))
│ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure"
│ ├── statements: ∅
│ └── end_keyword_loc: (29...32) = "end"
└── end_keyword_loc: (29...32) = "end"
│ └── end_keyword_loc: (9,0)-(9,3) = "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: []
└── statements:
@ StatementsNode (location: (0...23))
@ StatementsNode (location: (1,0)-(4,3))
└── body: (length: 1)
└── @ BeginNode (location: (0...23))
├── begin_keyword_loc: (0...5) = "begin"
└── @ BeginNode (location: (1,0)-(4,3))
├── begin_keyword_loc: (1,0)-(1,5) = "begin"
├── statements: ∅
├── rescue_clause:
│ @ RescueNode (location: (6...12))
│ ├── keyword_loc: (6...12) = "rescue"
│ @ RescueNode (location: (2,0)-(2,6))
│ ├── keyword_loc: (2,0)-(2,6) = "rescue"
│ ├── exceptions: (length: 0)
│ ├── operator_loc: ∅
│ ├── reference: ∅
@ -16,8 +16,8 @@
│ └── consequent: ∅
├── else_clause: ∅
├── ensure_clause:
│ @ EnsureNode (location: (13...23))
│ ├── ensure_keyword_loc: (13...19) = "ensure"
│ @ EnsureNode (location: (3,0)-(4,3))
│ ├── ensure_keyword_loc: (3,0)-(3,6) = "ensure"
│ ├── statements: ∅
│ └── end_keyword_loc: (20...23) = "end"
└── end_keyword_loc: (20...23) = "end"
│ └── end_keyword_loc: (4,0)-(4,3) = "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: []
└── statements:
@ StatementsNode (location: (0...13))
@ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1)
└── @ DefNode (location: (0...13))
└── @ DefNode (location: (1,0)-(1,13))
├── name: :x
├── name_loc: (4...5) = "x"
├── name_loc: (1,4)-(1,5) = "x"
├── receiver: ∅
├── parameters:
│ @ ParametersNode (location: (6...7))
│ @ ParametersNode (location: (1,6)-(1,7))
│ ├── requireds: (length: 0)
│ ├── optionals: (length: 0)
│ ├── rest: ∅
@ -16,15 +16,15 @@
│ ├── keywords: (length: 0)
│ ├── keyword_rest: ∅
│ └── block:
│ @ BlockParameterNode (location: (6...7))
│ @ BlockParameterNode (location: (1,6)-(1,7))
│ ├── name: nil
│ ├── name_loc: ∅
│ └── operator_loc: (6...7) = "&"
│ └── operator_loc: (1,6)-(1,7) = "&"
├── body: ∅
├── locals: [:&]
├── def_keyword_loc: (0...3) = "def"
├── def_keyword_loc: (1,0)-(1,3) = "def"
├── operator_loc: ∅
├── lparen_loc: (5...6) = "("
├── rparen_loc: (7...8) = ")"
├── lparen_loc: (1,5)-(1,6) = "("
├── rparen_loc: (1,7)-(1,8) = ")"
├── 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: []
└── statements:
@ StatementsNode (location: (0...11))
@ StatementsNode (location: (1,0)-(1,11))
└── body: (length: 1)
└── @ CallNode (location: (0...11))
└── @ CallNode (location: (1,0)-(1,11))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...11))
│ @ BlockNode (location: (1,2)-(1,11))
│ ├── locals: [:b]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...9))
│ │ @ BlockParametersNode (location: (1,4)-(1,9))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...8))
│ │ │ @ ParametersNode (location: (1,5)-(1,8))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (5...8))
│ │ │ │ @ KeywordRestParameterNode (location: (1,5)-(1,8))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (7...8) = "b"
│ │ │ │ └── operator_loc: (5...7) = "**"
│ │ │ │ ├── name_loc: (1,7)-(1,8) = "b"
│ │ │ │ └── operator_loc: (1,5)-(1,7) = "**"
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (8...9) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,8)-(1,9) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (10...11) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,10)-(1,11) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...21))
@ StatementsNode (location: (1,0)-(1,21))
└── body: (length: 1)
└── @ CallNode (location: (0...21))
└── @ CallNode (location: (1,0)-(1,21))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...21))
│ @ BlockNode (location: (1,2)-(1,21))
│ ├── locals: [:b, :c, :d, :e]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...19))
│ │ @ BlockParametersNode (location: (1,4)-(1,19))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...18))
│ │ │ @ ParametersNode (location: (1,5)-(1,18))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...11))
│ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,11))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c"
│ │ │ │ ├── operator_loc: (9...10) = "="
│ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (1,9)-(1,10) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (10...11))
│ │ │ │ @ IntegerNode (location: (1,10)-(1,11))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (13...14))
│ │ │ │ └── @ RequiredParameterNode (location: (1,13)-(1,14))
│ │ │ │ └── name: :d
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (16...18))
│ │ │ @ BlockParameterNode (location: (1,16)-(1,18))
│ │ │ ├── name: :e
│ │ │ ├── name_loc: (17...18) = "e"
│ │ │ └── operator_loc: (16...17) = "&"
│ │ │ ├── name_loc: (1,17)-(1,18) = "e"
│ │ │ └── operator_loc: (1,16)-(1,17) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (18...19) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,18)-(1,19) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (20...21) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,20)-(1,21) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...20))
@ StatementsNode (location: (1,0)-(1,20))
└── body: (length: 1)
└── @ CallNode (location: (0...20))
└── @ CallNode (location: (1,0)-(1,20))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...20))
│ @ BlockNode (location: (1,2)-(1,20))
│ ├── locals: [:b, :c, :d]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...18))
│ │ @ BlockParametersNode (location: (1,4)-(1,18))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...17))
│ │ │ @ ParametersNode (location: (1,5)-(1,17))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...13))
│ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,13))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c"
│ │ │ │ ├── operator_loc: (10...11) = "="
│ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (12...13))
│ │ │ │ @ IntegerNode (location: (1,12)-(1,13))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (15...17))
│ │ │ │ @ RestParameterNode (location: (1,15)-(1,17))
│ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (16...17) = "d"
│ │ │ │ └── operator_loc: (15...16) = "*"
│ │ │ │ ├── name_loc: (1,16)-(1,17) = "d"
│ │ │ │ └── operator_loc: (1,15)-(1,16) = "*"
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (17...18) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,17)-(1,18) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (19...20) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,19)-(1,20) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...25))
@ StatementsNode (location: (1,0)-(1,25))
└── body: (length: 1)
└── @ CallNode (location: (0...25))
└── @ CallNode (location: (1,0)-(1,25))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...25))
│ @ BlockNode (location: (1,2)-(1,25))
│ ├── locals: [:b, :c, :d, :e, :f]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...23))
│ │ @ BlockParametersNode (location: (1,4)-(1,23))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...22))
│ │ │ @ ParametersNode (location: (1,5)-(1,22))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...11))
│ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,11))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (8...9) = "c"
│ │ │ │ ├── operator_loc: (9...10) = "="
│ │ │ │ ├── name_loc: (1,8)-(1,9) = "c"
│ │ │ │ ├── operator_loc: (1,9)-(1,10) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (10...11))
│ │ │ │ @ IntegerNode (location: (1,10)-(1,11))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (13...15))
│ │ │ │ @ RestParameterNode (location: (1,13)-(1,15))
│ │ │ │ ├── name: :d
│ │ │ │ ├── name_loc: (14...15) = "d"
│ │ │ │ └── operator_loc: (13...14) = "*"
│ │ │ │ ├── name_loc: (1,14)-(1,15) = "d"
│ │ │ │ └── operator_loc: (1,13)-(1,14) = "*"
│ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (17...18))
│ │ │ │ └── @ RequiredParameterNode (location: (1,17)-(1,18))
│ │ │ │ └── name: :e
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (20...22))
│ │ │ @ BlockParameterNode (location: (1,20)-(1,22))
│ │ │ ├── name: :f
│ │ │ ├── name_loc: (21...22) = "f"
│ │ │ └── operator_loc: (20...21) = "&"
│ │ │ ├── name_loc: (1,21)-(1,22) = "f"
│ │ │ └── operator_loc: (1,20)-(1,21) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (22...23) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,22)-(1,23) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (24...25) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,24)-(1,25) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...13))
@ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1)
└── @ CallNode (location: (0...13))
└── @ CallNode (location: (1,0)-(1,13))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...13))
│ @ BlockNode (location: (1,2)-(1,13))
│ ├── locals: [:b]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...11))
│ │ @ BlockParametersNode (location: (1,4)-(1,11))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...10))
│ │ │ @ ParametersNode (location: (1,5)-(1,10))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (5...10))
│ │ │ │ └── @ OptionalParameterNode (location: (1,5)-(1,10))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (5...6) = "b"
│ │ │ │ ├── operator_loc: (7...8) = "="
│ │ │ │ ├── name_loc: (1,5)-(1,6) = "b"
│ │ │ │ ├── operator_loc: (1,7)-(1,8) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (9...10))
│ │ │ │ @ IntegerNode (location: (1,9)-(1,10))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
@ -32,10 +32,10 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (10...11) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,10)-(1,11) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (12...13) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,12)-(1,13) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...12))
@ StatementsNode (location: (1,0)-(1,12))
└── body: (length: 1)
└── @ CallNode (location: (0...12))
└── @ CallNode (location: (1,0)-(1,12))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...12))
│ @ BlockNode (location: (1,2)-(1,12))
│ ├── locals: [:b, :c]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...10))
│ │ @ BlockParametersNode (location: (1,4)-(1,10))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...6))
│ │ │ @ ParametersNode (location: (1,5)-(1,6))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -27,12 +27,12 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 1)
│ │ │ └── @ BlockLocalVariableNode (location: (8...9))
│ │ │ └── @ BlockLocalVariableNode (location: (1,8)-(1,9))
│ │ │ └── name: :c
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (9...10) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,9)-(1,10) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (11...12) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,11)-(1,12) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...14))
@ StatementsNode (location: (1,0)-(1,14))
└── body: (length: 1)
└── @ CallNode (location: (0...14))
└── @ CallNode (location: (1,0)-(1,14))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...14))
│ @ BlockNode (location: (1,2)-(1,14))
│ ├── locals: [:b, :c, :d]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (3...12))
│ │ @ BlockParametersNode (location: (1,3)-(1,12))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (4...5))
│ │ │ @ ParametersNode (location: (1,4)-(1,5))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (4...5))
│ │ │ │ └── @ RequiredParameterNode (location: (1,4)-(1,5))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -27,14 +27,14 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 2)
│ │ │ ├── @ BlockLocalVariableNode (location: (7...8))
│ │ │ ├── @ BlockLocalVariableNode (location: (1,7)-(1,8))
│ │ │ │ └── name: :c
│ │ │ └── @ BlockLocalVariableNode (location: (10...11))
│ │ │ └── @ BlockLocalVariableNode (location: (1,10)-(1,11))
│ │ │ └── name: :d
│ │ ├── opening_loc: (3...4) = "|"
│ │ └── closing_loc: (11...12) = "|"
│ │ ├── opening_loc: (1,3)-(1,4) = "|"
│ │ └── closing_loc: (1,11)-(1,12) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (13...14) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,13)-(1,14) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...16))
@ StatementsNode (location: (1,0)-(1,16))
└── body: (length: 1)
└── @ CallNode (location: (0...16))
└── @ CallNode (location: (1,0)-(1,16))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...16))
│ @ BlockNode (location: (1,2)-(1,16))
│ ├── locals: [:b, :c, :d]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...14))
│ │ @ BlockParametersNode (location: (1,4)-(1,14))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...13))
│ │ │ @ ParametersNode (location: (1,5)-(1,13))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :b
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest:
│ │ │ │ @ RestParameterNode (location: (8...10))
│ │ │ │ @ RestParameterNode (location: (1,8)-(1,10))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (9...10) = "c"
│ │ │ │ └── operator_loc: (8...9) = "*"
│ │ │ │ ├── name_loc: (1,9)-(1,10) = "c"
│ │ │ │ └── operator_loc: (1,8)-(1,9) = "*"
│ │ │ ├── posts: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (12...13))
│ │ │ │ └── @ RequiredParameterNode (location: (1,12)-(1,13))
│ │ │ │ └── name: :d
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (13...14) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,13)-(1,14) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (15...16) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,15)-(1,16) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...23))
@ StatementsNode (location: (1,0)-(1,23))
└── body: (length: 1)
└── @ CallNode (location: (0...23))
└── @ CallNode (location: (1,0)-(1,23))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "f"
├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...23))
│ @ BlockNode (location: (1,2)-(1,23))
│ ├── locals: [:kwargs]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...14))
│ │ @ BlockParametersNode (location: (1,4)-(1,14))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...13))
│ │ │ @ ParametersNode (location: (1,5)-(1,13))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest:
│ │ │ │ @ KeywordRestParameterNode (location: (5...13))
│ │ │ │ @ KeywordRestParameterNode (location: (1,5)-(1,13))
│ │ │ │ ├── name: :kwargs
│ │ │ │ ├── name_loc: (7...13) = "kwargs"
│ │ │ │ └── operator_loc: (5...7) = "**"
│ │ │ │ ├── name_loc: (1,7)-(1,13) = "kwargs"
│ │ │ │ └── operator_loc: (1,5)-(1,7) = "**"
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (13...14) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,13)-(1,14) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (15...21))
│ │ @ StatementsNode (location: (1,15)-(1,21))
│ │ └── body: (length: 1)
│ │ └── @ LocalVariableReadNode (location: (15...21))
│ │ └── @ LocalVariableReadNode (location: (1,15)-(1,21))
│ │ ├── name: :kwargs
│ │ └── depth: 0
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (22...23) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,22)-(1,23) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...13))
@ StatementsNode (location: (1,0)-(1,13))
└── body: (length: 1)
└── @ CallNode (location: (0...13))
└── @ CallNode (location: (1,0)-(1,13))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "f"
├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...13))
│ @ BlockNode (location: (1,2)-(1,13))
│ ├── locals: []
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...11))
│ │ @ BlockParametersNode (location: (1,4)-(1,11))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...10))
│ │ │ @ ParametersNode (location: (1,5)-(1,10))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest:
│ │ │ │ @ NoKeywordsParameterNode (location: (5...10))
│ │ │ │ ├── operator_loc: (5...7) = "**"
│ │ │ │ └── keyword_loc: (7...10) = "nil"
│ │ │ │ @ NoKeywordsParameterNode (location: (1,5)-(1,10))
│ │ │ │ ├── operator_loc: (1,5)-(1,7) = "**"
│ │ │ │ └── keyword_loc: (1,7)-(1,10) = "nil"
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (10...11) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,10)-(1,11) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (12...13) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,12)-(1,13) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...24))
@ StatementsNode (location: (1,0)-(1,24))
└── body: (length: 1)
└── @ CallNode (location: (0...24))
└── @ CallNode (location: (1,0)-(1,24))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "f"
├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...24))
│ @ BlockNode (location: (1,2)-(1,24))
│ ├── locals: [:a, :b]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...15))
│ │ @ BlockParametersNode (location: (1,4)-(1,15))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...14))
│ │ │ @ ParametersNode (location: (1,5)-(1,14))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 1)
│ │ │ │ └── @ OptionalParameterNode (location: (8...14))
│ │ │ │ └── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ ├── name: :b
│ │ │ │ ├── name_loc: (8...9) = "b"
│ │ │ │ ├── operator_loc: (10...11) = "="
│ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (12...14))
│ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
@ -34,22 +34,22 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (14...15) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,14)-(1,15) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (16...22))
│ │ @ StatementsNode (location: (1,16)-(1,22))
│ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (16...22))
│ │ └── @ ArrayNode (location: (1,16)-(1,22))
│ │ ├── elements: (length: 2)
│ │ │ ├── @ LocalVariableReadNode (location: (17...18))
│ │ │ ├── @ LocalVariableReadNode (location: (1,17)-(1,18))
│ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (20...21))
│ │ │ └── @ LocalVariableReadNode (location: (1,20)-(1,21))
│ │ │ ├── name: :b
│ │ │ └── depth: 0
│ │ ├── opening_loc: (16...17) = "["
│ │ └── closing_loc: (21...22) = "]"
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (23...24) = "}"
│ │ ├── opening_loc: (1,16)-(1,17) = "["
│ │ └── closing_loc: (1,21)-(1,22) = "]"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,23)-(1,24) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...18))
@ StatementsNode (location: (1,0)-(1,18))
└── body: (length: 1)
└── @ CallNode (location: (0...18))
└── @ CallNode (location: (1,0)-(1,18))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "a"
├── message_loc: (1,0)-(1,1) = "a"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...18))
│ @ BlockNode (location: (1,2)-(1,18))
│ ├── locals: [:b, :c]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...16))
│ │ @ BlockParametersNode (location: (1,4)-(1,16))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (6...14))
│ │ │ @ ParametersNode (location: (1,6)-(1,14))
│ │ │ ├── requireds: (length: 0)
│ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (6...9))
│ │ │ │ ├── @ OptionalParameterNode (location: (1,6)-(1,9))
│ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (6...7) = "b"
│ │ │ │ │ ├── operator_loc: (7...8) = "="
│ │ │ │ │ ├── name_loc: (1,6)-(1,7) = "b"
│ │ │ │ │ ├── operator_loc: (1,7)-(1,8) = "="
│ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (8...9))
│ │ │ │ │ @ IntegerNode (location: (1,8)-(1,9))
│ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (11...14))
│ │ │ │ └── @ OptionalParameterNode (location: (1,11)-(1,14))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (11...12) = "c"
│ │ │ │ ├── operator_loc: (12...13) = "="
│ │ │ │ ├── name_loc: (1,11)-(1,12) = "c"
│ │ │ │ ├── operator_loc: (1,12)-(1,13) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (13...14))
│ │ │ │ @ IntegerNode (location: (1,13)-(1,14))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
@ -39,10 +39,10 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (15...16) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,15)-(1,16) = "|"
│ ├── body: ∅
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (17...18) = "}"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,17)-(1,18) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...35))
@ StatementsNode (location: (1,0)-(1,35))
└── body: (length: 1)
└── @ CallNode (location: (0...35))
└── @ CallNode (location: (1,0)-(1,35))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "f"
├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...35))
│ @ BlockNode (location: (1,2)-(1,35))
│ ├── locals: [:a, :b, :c]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...23))
│ │ @ BlockParametersNode (location: (1,4)-(1,23))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...22))
│ │ │ @ ParametersNode (location: (1,5)-(1,22))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (8...14))
│ │ │ │ ├── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (8...9) = "b"
│ │ │ │ │ ├── operator_loc: (10...11) = "="
│ │ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (12...14))
│ │ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (16...22))
│ │ │ │ └── @ OptionalParameterNode (location: (1,16)-(1,22))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (16...17) = "c"
│ │ │ │ ├── operator_loc: (18...19) = "="
│ │ │ │ ├── name_loc: (1,16)-(1,17) = "c"
│ │ │ │ ├── operator_loc: (1,18)-(1,19) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (20...22))
│ │ │ │ @ IntegerNode (location: (1,20)-(1,22))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
@ -41,25 +41,25 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (22...23) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,22)-(1,23) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (24...33))
│ │ @ StatementsNode (location: (1,24)-(1,33))
│ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (24...33))
│ │ └── @ ArrayNode (location: (1,24)-(1,33))
│ │ ├── elements: (length: 3)
│ │ │ ├── @ LocalVariableReadNode (location: (25...26))
│ │ │ ├── @ LocalVariableReadNode (location: (1,25)-(1,26))
│ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (28...29))
│ │ │ ├── @ LocalVariableReadNode (location: (1,28)-(1,29))
│ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (31...32))
│ │ │ └── @ LocalVariableReadNode (location: (1,31)-(1,32))
│ │ │ ├── name: :c
│ │ │ └── depth: 0
│ │ ├── opening_loc: (24...25) = "["
│ │ └── closing_loc: (32...33) = "]"
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (34...35) = "}"
│ │ ├── opening_loc: (1,24)-(1,25) = "["
│ │ └── closing_loc: (1,32)-(1,33) = "]"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,34)-(1,35) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...42))
@ StatementsNode (location: (1,0)-(1,42))
└── body: (length: 1)
└── @ CallNode (location: (0...42))
└── @ CallNode (location: (1,0)-(1,42))
├── receiver: ∅
├── call_operator_loc: ∅
├── message_loc: (0...1) = "f"
├── message_loc: (1,0)-(1,1) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (2...42))
│ @ BlockNode (location: (1,2)-(1,42))
│ ├── locals: [:a, :b, :c, :d]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (4...27))
│ │ @ BlockParametersNode (location: (1,4)-(1,27))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (5...26))
│ │ │ @ ParametersNode (location: (1,5)-(1,26))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (5...6))
│ │ │ │ └── @ RequiredParameterNode (location: (1,5)-(1,6))
│ │ │ │ └── name: :a
│ │ │ ├── optionals: (length: 2)
│ │ │ │ ├── @ OptionalParameterNode (location: (8...14))
│ │ │ │ ├── @ OptionalParameterNode (location: (1,8)-(1,14))
│ │ │ │ │ ├── name: :b
│ │ │ │ │ ├── name_loc: (8...9) = "b"
│ │ │ │ │ ├── operator_loc: (10...11) = "="
│ │ │ │ │ ├── name_loc: (1,8)-(1,9) = "b"
│ │ │ │ │ ├── operator_loc: (1,10)-(1,11) = "="
│ │ │ │ │ └── value:
│ │ │ │ │ @ IntegerNode (location: (12...14))
│ │ │ │ │ @ IntegerNode (location: (1,12)-(1,14))
│ │ │ │ │ └── flags: decimal
│ │ │ │ └── @ OptionalParameterNode (location: (16...22))
│ │ │ │ └── @ OptionalParameterNode (location: (1,16)-(1,22))
│ │ │ │ ├── name: :c
│ │ │ │ ├── name_loc: (16...17) = "c"
│ │ │ │ ├── operator_loc: (18...19) = "="
│ │ │ │ ├── name_loc: (1,16)-(1,17) = "c"
│ │ │ │ ├── operator_loc: (1,18)-(1,19) = "="
│ │ │ │ └── value:
│ │ │ │ @ IntegerNode (location: (20...22))
│ │ │ │ @ IntegerNode (location: (1,20)-(1,22))
│ │ │ │ └── flags: decimal
│ │ │ ├── rest: ∅
│ │ │ ├── posts: (length: 0)
│ │ │ ├── keywords: (length: 0)
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block:
│ │ │ @ BlockParameterNode (location: (24...26))
│ │ │ @ BlockParameterNode (location: (1,24)-(1,26))
│ │ │ ├── name: :d
│ │ │ ├── name_loc: (25...26) = "d"
│ │ │ └── operator_loc: (24...25) = "&"
│ │ │ ├── name_loc: (1,25)-(1,26) = "d"
│ │ │ └── operator_loc: (1,24)-(1,25) = "&"
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (4...5) = "|"
│ │ └── closing_loc: (26...27) = "|"
│ │ ├── opening_loc: (1,4)-(1,5) = "|"
│ │ └── closing_loc: (1,26)-(1,27) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (28...40))
│ │ @ StatementsNode (location: (1,28)-(1,40))
│ │ └── body: (length: 1)
│ │ └── @ ArrayNode (location: (28...40))
│ │ └── @ ArrayNode (location: (1,28)-(1,40))
│ │ ├── elements: (length: 4)
│ │ │ ├── @ LocalVariableReadNode (location: (29...30))
│ │ │ ├── @ LocalVariableReadNode (location: (1,29)-(1,30))
│ │ │ │ ├── name: :a
│ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (32...33))
│ │ │ ├── @ LocalVariableReadNode (location: (1,32)-(1,33))
│ │ │ │ ├── name: :b
│ │ │ │ └── depth: 0
│ │ │ ├── @ LocalVariableReadNode (location: (35...36))
│ │ │ ├── @ LocalVariableReadNode (location: (1,35)-(1,36))
│ │ │ │ ├── name: :c
│ │ │ │ └── depth: 0
│ │ │ └── @ LocalVariableReadNode (location: (38...39))
│ │ │ └── @ LocalVariableReadNode (location: (1,38)-(1,39))
│ │ │ ├── name: :d
│ │ │ └── depth: 0
│ │ ├── opening_loc: (28...29) = "["
│ │ └── closing_loc: (39...40) = "]"
│ ├── opening_loc: (2...3) = "{"
│ └── closing_loc: (41...42) = "}"
│ │ ├── opening_loc: (1,28)-(1,29) = "["
│ │ └── closing_loc: (1,39)-(1,40) = "]"
│ ├── opening_loc: (1,2)-(1,3) = "{"
│ └── closing_loc: (1,41)-(1,42) = "}"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...26))
@ StatementsNode (location: (1,0)-(1,26))
└── body: (length: 1)
└── @ BreakNode (location: (0...26))
└── @ BreakNode (location: (1,0)-(1,26))
├── arguments:
│ @ ArgumentsNode (location: (6...26))
│ @ ArgumentsNode (location: (1,6)-(1,26))
│ └── arguments: (length: 1)
│ └── @ CallNode (location: (6...26))
│ └── @ CallNode (location: (1,6)-(1,26))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (6...9) = "foo"
│ ├── message_loc: (1,6)-(1,9) = "foo"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (10...13))
│ │ @ ArgumentsNode (location: (1,10)-(1,13))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (10...13))
│ │ └── @ CallNode (location: (1,10)-(1,13))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (10...13) = "arg"
│ │ ├── message_loc: (1,10)-(1,13) = "arg"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -27,14 +27,14 @@
│ │ └── name: "arg"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (14...26))
│ │ @ BlockNode (location: (1,14)-(1,26))
│ │ ├── locals: [:bar]
│ │ ├── parameters:
│ │ │ @ BlockParametersNode (location: (17...22))
│ │ │ @ BlockParametersNode (location: (1,17)-(1,22))
│ │ │ ├── parameters:
│ │ │ │ @ ParametersNode (location: (18...21))
│ │ │ │ @ ParametersNode (location: (1,18)-(1,21))
│ │ │ │ ├── requireds: (length: 1)
│ │ │ │ │ └── @ RequiredParameterNode (location: (18...21))
│ │ │ │ │ └── @ RequiredParameterNode (location: (1,18)-(1,21))
│ │ │ │ │ └── name: :bar
│ │ │ │ ├── optionals: (length: 0)
│ │ │ │ ├── rest: ∅
@ -43,11 +43,11 @@
│ │ │ │ ├── keyword_rest: ∅
│ │ │ │ └── block: ∅
│ │ │ ├── locals: (length: 0)
│ │ │ ├── opening_loc: (17...18) = "|"
│ │ │ └── closing_loc: (21...22) = "|"
│ │ │ ├── opening_loc: (1,17)-(1,18) = "|"
│ │ │ └── closing_loc: (1,21)-(1,22) = "|"
│ │ ├── body: ∅
│ │ ├── opening_loc: (14...16) = "do"
│ │ └── closing_loc: (23...26) = "end"
│ │ ├── opening_loc: (1,14)-(1,16) = "do"
│ │ └── closing_loc: (1,23)-(1,26) = "end"
│ ├── flags: ∅
│ └── 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: []
└── statements:
@ StatementsNode (location: (0...30))
@ StatementsNode (location: (1,0)-(4,11))
└── body: (length: 2)
├── @ CallNode (location: (0...18))
├── @ CallNode (location: (1,0)-(3,4))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a"
│ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (2...18))
│ │ @ ArgumentsNode (location: (1,2)-(3,4))
│ │ └── arguments: (length: 1)
│ │ └── @ DefNode (location: (2...18))
│ │ └── @ DefNode (location: (1,2)-(3,4))
│ │ ├── name: :b
│ │ ├── name_loc: (6...7) = "b"
│ │ ├── name_loc: (1,6)-(1,7) = "b"
│ │ ├── receiver: ∅
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (8...9))
│ │ │ @ ParametersNode (location: (1,8)-(1,9))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (8...9))
│ │ │ │ └── @ RequiredParameterNode (location: (1,8)-(1,9))
│ │ │ │ └── name: :c
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -27,12 +27,12 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (12...13))
│ │ │ @ StatementsNode (location: (2,1)-(2,2))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (12...13))
│ │ │ └── @ CallNode (location: (2,1)-(2,2))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (12...13) = "d"
│ │ │ ├── message_loc: (2,1)-(2,2) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
@ -40,39 +40,39 @@
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ ├── locals: [:c]
│ │ ├── def_keyword_loc: (2...5) = "def"
│ │ ├── def_keyword_loc: (1,2)-(1,5) = "def"
│ │ ├── operator_loc: ∅
│ │ ├── lparen_loc: (7...8) = "("
│ │ ├── rparen_loc: (9...10) = ")"
│ │ ├── lparen_loc: (1,7)-(1,8) = "("
│ │ ├── rparen_loc: (1,9)-(1,10) = ")"
│ │ ├── equal_loc: ∅
│ │ └── end_keyword_loc: (15...18) = "end"
│ │ └── end_keyword_loc: (3,1)-(3,4) = "end"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "a"
└── @ CallNode (location: (20...30))
└── @ CallNode (location: (4,1)-(4,11))
├── receiver:
│ @ CallNode (location: (20...21))
│ @ CallNode (location: (4,1)-(4,2))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (20...21) = "e"
│ ├── message_loc: (4,1)-(4,2) = "e"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "e"
├── call_operator_loc: (21...22) = "."
├── message_loc: (22...23) = "f"
├── call_operator_loc: (4,2)-(4,3) = "."
├── message_loc: (4,3)-(4,4) = "f"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (24...30))
│ @ BlockNode (location: (4,5)-(4,11))
│ ├── locals: []
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── opening_loc: (24...26) = "do"
│ └── closing_loc: (27...30) = "end"
│ ├── opening_loc: (4,5)-(4,7) = "do"
│ └── closing_loc: (4,8)-(4,11) = "end"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...31))
@ StatementsNode (location: (1,0)-(1,31))
└── body: (length: 1)
└── @ CallNode (location: (0...31))
└── @ CallNode (location: (1,0)-(1,31))
├── receiver:
│ @ CallNode (location: (0...16))
│ @ CallNode (location: (1,0)-(1,16))
│ ├── receiver:
│ │ @ CallNode (location: (0...1))
│ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a"
│ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "."
│ ├── message_loc: (2...3) = "b"
│ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7))
│ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7))
│ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c"
│ │ ├── opening_loc: (5...6) = "("
│ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: (1,5)-(1,6) = "("
│ │ ├── arguments: ∅
│ │ ├── closing_loc: (6...7) = ")"
│ │ ├── closing_loc: (1,6)-(1,7) = ")"
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "c"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (8...16))
│ │ @ BlockNode (location: (1,8)-(1,16))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (11...12))
│ │ │ @ StatementsNode (location: (1,11)-(1,12))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...12))
│ │ │ └── @ CallNode (location: (1,11)-(1,12))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...12) = "d"
│ │ │ ├── message_loc: (1,11)-(1,12) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ ├── opening_loc: (8...10) = "do"
│ │ └── closing_loc: (13...16) = "end"
│ │ ├── opening_loc: (1,8)-(1,10) = "do"
│ │ └── closing_loc: (1,13)-(1,16) = "end"
│ ├── flags: ∅
│ └── name: "b"
├── call_operator_loc: (16...17) = "."
├── message_loc: (17...18) = "e"
├── call_operator_loc: (1,16)-(1,17) = "."
├── message_loc: (1,17)-(1,18) = "e"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (19...31))
│ @ BlockNode (location: (1,19)-(1,31))
│ ├── locals: [:f]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (22...25))
│ │ @ BlockParametersNode (location: (1,22)-(1,25))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (23...24))
│ │ │ @ ParametersNode (location: (1,23)-(1,24))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (23...24))
│ │ │ │ └── @ RequiredParameterNode (location: (1,23)-(1,24))
│ │ │ │ └── name: :f
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -77,22 +77,22 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (22...23) = "|"
│ │ └── closing_loc: (24...25) = "|"
│ │ ├── opening_loc: (1,22)-(1,23) = "|"
│ │ └── closing_loc: (1,24)-(1,25) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (26...27))
│ │ @ StatementsNode (location: (1,26)-(1,27))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (26...27))
│ │ └── @ CallNode (location: (1,26)-(1,27))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (26...27) = "g"
│ │ ├── message_loc: (1,26)-(1,27) = "g"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "g"
│ ├── opening_loc: (19...21) = "do"
│ └── closing_loc: (28...31) = "end"
│ ├── opening_loc: (1,19)-(1,21) = "do"
│ └── closing_loc: (1,28)-(1,31) = "end"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...33))
@ StatementsNode (location: (1,0)-(1,33))
└── body: (length: 1)
└── @ CallNode (location: (0...33))
└── @ CallNode (location: (1,0)-(1,33))
├── receiver:
│ @ CallNode (location: (0...16))
│ @ CallNode (location: (1,0)-(1,16))
│ ├── receiver:
│ │ @ CallNode (location: (0...1))
│ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a"
│ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "."
│ ├── message_loc: (2...3) = "b"
│ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...7))
│ │ @ ArgumentsNode (location: (1,4)-(1,7))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...7))
│ │ └── @ CallNode (location: (1,4)-(1,7))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c"
│ │ ├── opening_loc: (5...6) = "("
│ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: (1,5)-(1,6) = "("
│ │ ├── arguments: ∅
│ │ ├── closing_loc: (6...7) = ")"
│ │ ├── closing_loc: (1,6)-(1,7) = ")"
│ │ ├── block: ∅
│ │ ├── flags: ∅
│ │ └── name: "c"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (8...16))
│ │ @ BlockNode (location: (1,8)-(1,16))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body:
│ │ │ @ StatementsNode (location: (11...12))
│ │ │ @ StatementsNode (location: (1,11)-(1,12))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (11...12))
│ │ │ └── @ CallNode (location: (1,11)-(1,12))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (11...12) = "d"
│ │ │ ├── message_loc: (1,11)-(1,12) = "d"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "d"
│ │ ├── opening_loc: (8...10) = "do"
│ │ └── closing_loc: (13...16) = "end"
│ │ ├── opening_loc: (1,8)-(1,10) = "do"
│ │ └── closing_loc: (1,13)-(1,16) = "end"
│ ├── flags: ∅
│ └── name: "b"
├── call_operator_loc: (16...17) = "."
├── message_loc: (17...18) = "e"
├── call_operator_loc: (1,16)-(1,17) = "."
├── message_loc: (1,17)-(1,18) = "e"
├── opening_loc: ∅
├── arguments:
│ @ ArgumentsNode (location: (19...20))
│ @ ArgumentsNode (location: (1,19)-(1,20))
│ └── arguments: (length: 1)
│ └── @ CallNode (location: (19...20))
│ └── @ CallNode (location: (1,19)-(1,20))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (19...20) = "f"
│ ├── message_loc: (1,19)-(1,20) = "f"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
@ -73,14 +73,14 @@
│ └── name: "f"
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (21...33))
│ @ BlockNode (location: (1,21)-(1,33))
│ ├── locals: [:g]
│ ├── parameters:
│ │ @ BlockParametersNode (location: (24...27))
│ │ @ BlockParametersNode (location: (1,24)-(1,27))
│ │ ├── parameters:
│ │ │ @ ParametersNode (location: (25...26))
│ │ │ @ ParametersNode (location: (1,25)-(1,26))
│ │ │ ├── requireds: (length: 1)
│ │ │ │ └── @ RequiredParameterNode (location: (25...26))
│ │ │ │ └── @ RequiredParameterNode (location: (1,25)-(1,26))
│ │ │ │ └── name: :g
│ │ │ ├── optionals: (length: 0)
│ │ │ ├── rest: ∅
@ -89,22 +89,22 @@
│ │ │ ├── keyword_rest: ∅
│ │ │ └── block: ∅
│ │ ├── locals: (length: 0)
│ │ ├── opening_loc: (24...25) = "|"
│ │ └── closing_loc: (26...27) = "|"
│ │ ├── opening_loc: (1,24)-(1,25) = "|"
│ │ └── closing_loc: (1,26)-(1,27) = "|"
│ ├── body:
│ │ @ StatementsNode (location: (28...29))
│ │ @ StatementsNode (location: (1,28)-(1,29))
│ │ └── body: (length: 1)
│ │ └── @ CallNode (location: (28...29))
│ │ └── @ CallNode (location: (1,28)-(1,29))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (28...29) = "h"
│ │ ├── message_loc: (1,28)-(1,29) = "h"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "h"
│ ├── opening_loc: (21...23) = "do"
│ └── closing_loc: (30...33) = "end"
│ ├── opening_loc: (1,21)-(1,23) = "do"
│ └── closing_loc: (1,30)-(1,33) = "end"
├── flags: ∅
└── 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: []
└── statements:
@ StatementsNode (location: (0...15))
@ StatementsNode (location: (1,0)-(1,15))
└── body: (length: 1)
└── @ CallNode (location: (0...15))
└── @ CallNode (location: (1,0)-(1,15))
├── receiver:
│ @ CallNode (location: (0...12))
│ @ CallNode (location: (1,0)-(1,12))
│ ├── receiver:
│ │ @ CallNode (location: (0...1))
│ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a"
│ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "."
│ ├── message_loc: (2...3) = "b"
│ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...5))
│ │ @ ArgumentsNode (location: (1,4)-(1,5))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...5))
│ │ └── @ CallNode (location: (1,4)-(1,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c"
│ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -35,16 +35,16 @@
│ │ └── name: "c"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (6...12))
│ │ @ BlockNode (location: (1,6)-(1,12))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (6...8) = "do"
│ │ └── closing_loc: (9...12) = "end"
│ │ ├── opening_loc: (1,6)-(1,8) = "do"
│ │ └── closing_loc: (1,9)-(1,12) = "end"
│ ├── flags: ∅
│ └── name: "b"
├── call_operator_loc: (12...14) = "::"
├── message_loc: (14...15) = "d"
├── call_operator_loc: (1,12)-(1,14) = "::"
├── message_loc: (1,14)-(1,15) = "d"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...14))
@ StatementsNode (location: (1,0)-(1,14))
└── body: (length: 1)
└── @ CallNode (location: (0...14))
└── @ CallNode (location: (1,0)-(1,14))
├── receiver:
│ @ CallNode (location: (0...12))
│ @ CallNode (location: (1,0)-(1,12))
│ ├── receiver:
│ │ @ CallNode (location: (0...1))
│ │ @ CallNode (location: (1,0)-(1,1))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (0...1) = "a"
│ │ ├── message_loc: (1,0)-(1,1) = "a"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
│ │ ├── block: ∅
│ │ ├── flags: variable_call
│ │ └── name: "a"
│ ├── call_operator_loc: (1...2) = "."
│ ├── message_loc: (2...3) = "b"
│ ├── call_operator_loc: (1,1)-(1,2) = "."
│ ├── message_loc: (1,2)-(1,3) = "b"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (4...5))
│ │ @ ArgumentsNode (location: (1,4)-(1,5))
│ │ └── arguments: (length: 1)
│ │ └── @ CallNode (location: (4...5))
│ │ └── @ CallNode (location: (1,4)-(1,5))
│ │ ├── receiver: ∅
│ │ ├── call_operator_loc: ∅
│ │ ├── message_loc: (4...5) = "c"
│ │ ├── message_loc: (1,4)-(1,5) = "c"
│ │ ├── opening_loc: ∅
│ │ ├── arguments: ∅
│ │ ├── closing_loc: ∅
@ -35,16 +35,16 @@
│ │ └── name: "c"
│ ├── closing_loc: ∅
│ ├── block:
│ │ @ BlockNode (location: (6...12))
│ │ @ BlockNode (location: (1,6)-(1,12))
│ │ ├── locals: []
│ │ ├── parameters: ∅
│ │ ├── body: ∅
│ │ ├── opening_loc: (6...8) = "do"
│ │ └── closing_loc: (9...12) = "end"
│ │ ├── opening_loc: (1,6)-(1,8) = "do"
│ │ └── closing_loc: (1,9)-(1,12) = "end"
│ ├── flags: ∅
│ └── name: "b"
├── call_operator_loc: (12...13) = "."
├── message_loc: (13...14) = "d"
├── call_operator_loc: (1,12)-(1,13) = "."
├── message_loc: (1,13)-(1,14) = "d"
├── opening_loc: ∅
├── arguments: ∅
├── 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: []
└── statements:
@ StatementsNode (location: (0...16))
@ StatementsNode (location: (1,0)-(2,10))
└── body: (length: 2)
├── @ CallNode (location: (0...5))
├── @ CallNode (location: (1,0)-(1,5))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (0...1) = "a"
│ ├── message_loc: (1,0)-(1,1) = "a"
│ ├── opening_loc: ∅
│ ├── arguments:
│ │ @ ArgumentsNode (location: (2...5))
│ │ @ ArgumentsNode (location: (1,2)-(1,5))
│ │ └── arguments: (length: 1)
│ │ └── @ ParenthesesNode (location: (2...5))
│ │ └── @ ParenthesesNode (location: (1,2)-(1,5))
│ │ ├── body:
│ │ │ @ StatementsNode (location: (3...4))
│ │ │ @ StatementsNode (location: (1,3)-(1,4))
│ │ │ └── body: (length: 1)
│ │ │ └── @ CallNode (location: (3...4))
│ │ │ └── @ CallNode (location: (1,3)-(1,4))
│ │ │ ├── receiver: ∅
│ │ │ ├── call_operator_loc: ∅
│ │ │ ├── message_loc: (3...4) = "b"
│ │ │ ├── message_loc: (1,3)-(1,4) = "b"
│ │ │ ├── opening_loc: ∅
│ │ │ ├── arguments: ∅
│ │ │ ├── closing_loc: ∅
│ │ │ ├── block: ∅
│ │ │ ├── flags: variable_call
│ │ │ └── name: "b"
│ │ ├── opening_loc: (2...3) = "("
│ │ └── closing_loc: (4...5) = ")"
│ │ ├── opening_loc: (1,2)-(1,3) = "("
│ │ └── closing_loc: (1,4)-(1,5) = ")"
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: ∅
│ └── name: "a"
└── @ CallNode (location: (6...16))
└── @ CallNode (location: (2,0)-(2,10))
├── receiver:
│ @ CallNode (location: (6...7))
│ @ CallNode (location: (2,0)-(2,1))
│ ├── receiver: ∅
│ ├── call_operator_loc: ∅
│ ├── message_loc: (6...7) = "c"
│ ├── message_loc: (2,0)-(2,1) = "c"
│ ├── opening_loc: ∅
│ ├── arguments: ∅
│ ├── closing_loc: ∅
│ ├── block: ∅
│ ├── flags: variable_call
│ └── name: "c"
├── call_operator_loc: (7...8) = "."
├── message_loc: (8...9) = "d"
├── call_operator_loc: (2,1)-(2,2) = "."
├── message_loc: (2,2)-(2,3) = "d"
├── opening_loc: ∅
├── arguments: ∅
├── closing_loc: ∅
├── block:
│ @ BlockNode (location: (10...16))
│ @ BlockNode (location: (2,4)-(2,10))
│ ├── locals: []
│ ├── parameters: ∅
│ ├── body: ∅
│ ├── opening_loc: (10...12) = "do"
│ └── closing_loc: (13...16) = "end"
│ ├── opening_loc: (2,4)-(2,6) = "do"
│ └── closing_loc: (2,7)-(2,10) = "end"
├── flags: ∅
└── name: "d"

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