diff options
author | Kevin Newton <kddnewton@gmail.com> | 2023-09-27 12:22:36 -0400 |
---|---|---|
committer | Kevin Newton <kddnewton@gmail.com> | 2023-09-27 13:57:38 -0400 |
commit | 8ab56869a64fdccc094f4a83c6367fb23b72d38b (patch) | |
tree | 46ef2bd5c51d5b7f923eda6a60edefc7a08200db /test/prism/snapshots/rescue.txt | |
parent | 7e0971eb5d679bb6219abb0ec238139aa6502c5a (diff) |
Rename YARP filepaths to prism filepaths
Diffstat (limited to 'test/prism/snapshots/rescue.txt')
-rw-r--r-- | test/prism/snapshots/rescue.txt | 378 |
1 files changed, 378 insertions, 0 deletions
diff --git a/test/prism/snapshots/rescue.txt b/test/prism/snapshots/rescue.txt new file mode 100644 index 0000000000..b57f5de7a7 --- /dev/null +++ b/test/prism/snapshots/rescue.txt @@ -0,0 +1,378 @@ +@ ProgramNode (location: (1,0)-(31,3)) +├── locals: [:a] +└── statements: + @ StatementsNode (location: (1,0)-(31,3)) + └── body: (length: 12) + ├── @ RescueModifierNode (location: (1,0)-(1,14)) + │ ├── expression: + │ │ @ CallNode (location: (1,0)-(1,3)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (1,0)-(1,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "foo" + │ ├── keyword_loc: (1,4)-(1,10) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (1,11)-(1,14)) + ├── @ RescueModifierNode (location: (3,0)-(4,3)) + │ ├── expression: + │ │ @ CallNode (location: (3,0)-(3,3)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (3,0)-(3,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "foo" + │ ├── keyword_loc: (3,4)-(3,10) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (4,0)-(4,3)) + ├── @ RescueModifierNode (location: (6,0)-(6,16)) + │ ├── expression: + │ │ @ BreakNode (location: (6,0)-(6,5)) + │ │ ├── arguments: ∅ + │ │ └── keyword_loc: (6,0)-(6,5) = "break" + │ ├── keyword_loc: (6,6)-(6,12) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (6,13)-(6,16)) + ├── @ RescueModifierNode (location: (8,0)-(8,15)) + │ ├── expression: + │ │ @ NextNode (location: (8,0)-(8,4)) + │ │ ├── arguments: ∅ + │ │ └── keyword_loc: (8,0)-(8,4) = "next" + │ ├── keyword_loc: (8,5)-(8,11) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (8,12)-(8,15)) + ├── @ RescueModifierNode (location: (10,0)-(10,17)) + │ ├── expression: + │ │ @ ReturnNode (location: (10,0)-(10,6)) + │ │ ├── keyword_loc: (10,0)-(10,6) = "return" + │ │ └── arguments: ∅ + │ ├── keyword_loc: (10,7)-(10,13) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (10,14)-(10,17)) + ├── @ RescueModifierNode (location: (12,0)-(12,19)) + │ ├── expression: + │ │ @ CallNode (location: (12,0)-(12,3)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (12,0)-(12,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "foo" + │ ├── keyword_loc: (12,4)-(12,10) = "rescue" + │ └── rescue_expression: + │ @ OrNode (location: (12,11)-(12,19)) + │ ├── left: + │ │ @ NilNode (location: (12,11)-(12,14)) + │ ├── right: + │ │ @ IntegerNode (location: (12,18)-(12,19)) + │ │ └── flags: decimal + │ └── operator_loc: (12,15)-(12,17) = "||" + ├── @ RescueModifierNode (location: (14,0)-(14,22)) + │ ├── expression: + │ │ @ CallNode (location: (14,0)-(14,3)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (14,0)-(14,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "foo" + │ ├── keyword_loc: (14,4)-(14,10) = "rescue" + │ └── rescue_expression: + │ @ IfNode (location: (14,11)-(14,22)) + │ ├── if_keyword_loc: ∅ + │ ├── predicate: + │ │ @ NilNode (location: (14,11)-(14,14)) + │ ├── statements: + │ │ @ StatementsNode (location: (14,17)-(14,18)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (14,17)-(14,18)) + │ │ └── flags: decimal + │ ├── consequent: + │ │ @ ElseNode (location: (14,19)-(14,22)) + │ │ ├── else_keyword_loc: (14,19)-(14,20) = ":" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (14,21)-(14,22)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ IntegerNode (location: (14,21)-(14,22)) + │ │ │ └── flags: decimal + │ │ └── end_keyword_loc: ∅ + │ └── end_keyword_loc: ∅ + ├── @ BeginNode (location: (16,0)-(16,24)) + │ ├── begin_keyword_loc: (16,0)-(16,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (16,7)-(16,8)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (16,7)-(16,8)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (16,7)-(16,8) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "a" + │ ├── rescue_clause: + │ │ @ RescueNode (location: (16,10)-(16,19)) + │ │ ├── keyword_loc: (16,10)-(16,16) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ SplatNode (location: (16,17)-(16,19)) + │ │ │ ├── operator_loc: (16,17)-(16,18) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (16,18)-(16,19)) + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── message_loc: (16,18)-(16,19) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ ├── block: ∅ + │ │ │ ├── flags: variable_call + │ │ │ └── name: "b" + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (16,21)-(16,24) = "end" + ├── @ CallNode (location: (18,0)-(20,3)) + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── message_loc: (18,0)-(18,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ ├── block: + │ │ @ BlockNode (location: (18,4)-(20,3)) + │ │ ├── locals: [:x] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (18,7)-(18,10)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (18,8)-(18,9)) + │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (18,8)-(18,9)) + │ │ │ │ │ └── name: :x + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (18,7)-(18,8) = "|" + │ │ │ └── closing_loc: (18,9)-(18,10) = "|" + │ │ ├── body: + │ │ │ @ StatementsNode (location: (19,2)-(19,40)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ RescueModifierNode (location: (19,2)-(19,40)) + │ │ │ ├── expression: + │ │ │ │ @ CallNode (location: (19,2)-(19,8)) + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── message_loc: (19,2)-(19,5) = "bar" + │ │ │ │ ├── opening_loc: (19,5)-(19,6) = "(" + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (19,6)-(19,7)) + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (19,6)-(19,7)) + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── message_loc: (19,6)-(19,7) = "y" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ ├── block: ∅ + │ │ │ │ │ ├── flags: variable_call + │ │ │ │ │ └── name: "y" + │ │ │ │ ├── closing_loc: (19,7)-(19,8) = ")" + │ │ │ │ ├── block: ∅ + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: "bar" + │ │ │ ├── keyword_loc: (19,9)-(19,15) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ CallNode (location: (19,16)-(19,40)) + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── message_loc: (19,16)-(19,29) = "ArgumentError" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (19,30)-(19,40)) + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (19,30)-(19,40)) + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── message_loc: (19,30)-(19,34) = "fail" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: + │ │ │ │ │ @ ArgumentsNode (location: (19,35)-(19,40)) + │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ └── @ StringNode (location: (19,35)-(19,40)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── opening_loc: (19,35)-(19,36) = "\"" + │ │ │ │ │ ├── content_loc: (19,36)-(19,39) = "baz" + │ │ │ │ │ ├── closing_loc: (19,39)-(19,40) = "\"" + │ │ │ │ │ └── unescaped: "baz" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ ├── block: ∅ + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: "fail" + │ │ │ ├── closing_loc: ∅ + │ │ │ ├── block: ∅ + │ │ │ ├── flags: ∅ + │ │ │ └── name: "ArgumentError" + │ │ ├── opening_loc: (18,4)-(18,6) = "do" + │ │ └── closing_loc: (20,0)-(20,3) = "end" + │ ├── flags: ∅ + │ └── name: "foo" + ├── @ IfNode (location: (22,0)-(24,3)) + │ ├── if_keyword_loc: (22,0)-(22,2) = "if" + │ ├── predicate: + │ │ @ LocalVariableWriteNode (location: (22,3)-(22,21)) + │ │ ├── name: :a + │ │ ├── depth: 0 + │ │ ├── name_loc: (22,3)-(22,4) = "a" + │ │ ├── value: + │ │ │ @ RescueModifierNode (location: (22,7)-(22,21)) + │ │ │ ├── expression: + │ │ │ │ @ CallNode (location: (22,7)-(22,10)) + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── message_loc: (22,7)-(22,10) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ ├── block: ∅ + │ │ │ │ ├── flags: variable_call + │ │ │ │ └── name: "foo" + │ │ │ ├── keyword_loc: (22,11)-(22,17) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ NilNode (location: (22,18)-(22,21)) + │ │ └── operator_loc: (22,5)-(22,6) = "=" + │ ├── statements: + │ │ @ StatementsNode (location: (23,2)-(23,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (23,2)-(23,5)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (23,2)-(23,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: variable_call + │ │ └── name: "bar" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (24,0)-(24,3) = "end" + ├── @ DefNode (location: (26,0)-(26,44)) + │ ├── name: :some_method + │ ├── name_loc: (26,4)-(26,15) = "some_method" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (26,18)-(26,44)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (26,18)-(26,44)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (26,18)-(26,30) = "other_method" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (26,31)-(26,44)) + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ RescueModifierNode (location: (26,31)-(26,44)) + │ │ │ ├── expression: + │ │ │ │ @ IntegerNode (location: (26,31)-(26,33)) + │ │ │ │ └── flags: decimal + │ │ │ ├── keyword_loc: (26,34)-(26,40) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ NilNode (location: (26,41)-(26,44)) + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: ∅ + │ │ └── name: "other_method" + │ ├── locals: [] + │ ├── def_keyword_loc: (26,0)-(26,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: (26,16)-(26,17) = "=" + │ └── end_keyword_loc: ∅ + └── @ DefNode (location: (28,0)-(31,3)) + ├── name: :a + ├── name_loc: (28,4)-(28,5) = "a" + ├── receiver: ∅ + ├── parameters: ∅ + ├── body: + │ @ BeginNode (location: (29,2)-(31,3)) + │ ├── begin_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (29,2)-(29,6)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (29,2)-(29,6)) + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── message_loc: (29,2)-(29,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (29,4)-(29,6)) + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ KeywordHashNode (location: (29,4)-(29,6)) + │ │ │ └── elements: (length: 1) + │ │ │ └── @ AssocNode (location: (29,4)-(29,6)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (29,4)-(29,6)) + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (29,4)-(29,5) = "b" + │ │ │ │ ├── closing_loc: (29,5)-(29,6) = ":" + │ │ │ │ └── unescaped: "b" + │ │ │ ├── value: + │ │ │ │ @ ImplicitNode (location: (29,4)-(29,6)) + │ │ │ │ └── value: + │ │ │ │ @ CallNode (location: (29,4)-(29,6)) + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── message_loc: (29,4)-(29,5) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ ├── block: ∅ + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: "b" + │ │ │ └── operator_loc: ∅ + │ │ ├── closing_loc: ∅ + │ │ ├── block: ∅ + │ │ ├── flags: ∅ + │ │ └── name: "a" + │ ├── rescue_clause: + │ │ @ RescueNode (location: (30,0)-(30,6)) + │ │ ├── keyword_loc: (30,0)-(30,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (31,0)-(31,3) = "end" + ├── locals: [] + ├── def_keyword_loc: (28,0)-(28,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: ∅ + ├── rparen_loc: ∅ + ├── equal_loc: ∅ + └── end_keyword_loc: (31,0)-(31,3) = "end" |