diff --git a/config.yml b/config.yml index 7c283741d3..42741fc330 100644 --- a/config.yml +++ b/config.yml @@ -3016,9 +3016,9 @@ nodes: - name: statements type: node? kind: StatementsNode - - name: in_loc + - name: in_keyword_loc type: location - - name: then_loc + - name: then_keyword_loc type: location? comment: | Represents the use of the `in` keyword in a case statement. @@ -3603,7 +3603,7 @@ nodes: - name: pattern type: node kind: pattern expression - - name: operator_loc + - name: keyword_loc type: location comment: | Represents the use of the modifier `in` operator. @@ -4576,7 +4576,7 @@ nodes: ^^^^^^^^^^^^^^^^^^^^^^ - name: UnlessNode fields: - - name: keyword_loc + - name: unless_keyword_loc type: location comment: | The Location of the `unless` keyword. @@ -4640,11 +4640,11 @@ nodes: - name: UntilNode flags: LoopFlags fields: - - name: keyword_loc + - name: until_keyword_loc type: location - name: do_keyword_loc type: location? - - name: closing_loc + - name: end_keyword_loc type: location? - name: predicate type: node @@ -4663,7 +4663,7 @@ nodes: ^^^^^^^^^^^^^^^^^^^^ - name: WhenNode fields: - - name: keyword_loc + - name: when_keyword_loc type: location - name: conditions type: node[] @@ -4683,11 +4683,11 @@ nodes: - name: WhileNode flags: LoopFlags fields: - - name: keyword_loc + - name: while_keyword_loc type: location - name: do_keyword_loc type: location? - - name: closing_loc + - name: end_keyword_loc type: location? - name: predicate type: node diff --git a/lib/prism/node_ext.rb b/lib/prism/node_ext.rb index aa9dba57c7..c0b632bc09 100644 --- a/lib/prism/node_ext.rb +++ b/lib/prism/node_ext.rb @@ -388,4 +388,106 @@ def full_message_loc attribute_write? ? message_loc&.adjoin("=") : message_loc end end + + class InNode < Node + #: () -> String + def in # :nodoc + in_keyword + end + + #: () -> Location + def in_loc # :nodoc + in_keyword_loc + end + + #: () -> String? + def then # :nodoc + then_keyword + end + + #: () -> Location? + def then_loc # :nodoc + then_keyword_loc + end + end + + class MatchPredicateNode < Node + #: () -> String + def operator # :nodoc + keyword + end + + #: () -> Location + def operator_loc # :nodoc + keyword_loc + end + end + + class UnlessNode < Node + #: () -> String + def keyword # :nodoc + unless_keyword + end + + #: () -> Location + def keyword_loc # :nodoc + unless_keyword_loc + end + end + + class UntilNode < Node + #: () -> String + def keyword # :nodoc + until_keyword + end + + #: () -> Location + def keyword_loc # :nodoc + until_keyword_loc + end + + #: () -> String? + def closing # :nodoc + end_keyword + end + + #: () -> Location? + def closing_loc # :nodoc + end_keyword_loc + end + end + + class WhenNode < Node + #: () -> String + def keyword # :nodoc + when_keyword + end + + #: () -> Location + def keyword_loc # :nodoc + when_keyword_loc + end + end + + class WhileNode < Node + #: () -> String + def keyword # :nodoc + while_keyword + end + + #: () -> Location + def keyword_loc # :nodoc + while_keyword_loc + end + + #: () -> String? + def closing # :nodoc + end_keyword + end + + #: () -> Location? + def closing_loc # :nodoc + end_keyword_loc + end + end end diff --git a/lib/prism/translation/parser/compiler.rb b/lib/prism/translation/parser/compiler.rb index d4e94ae5e0..9f18b2c691 100644 --- a/lib/prism/translation/parser/compiler.rb +++ b/lib/prism/translation/parser/compiler.rb @@ -975,17 +975,17 @@ def visit_in_node(node) guard = builder.if_guard(token(node.pattern.if_keyword_loc), visit(node.pattern.predicate)) when UnlessNode pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) } - guard = builder.unless_guard(token(node.pattern.keyword_loc), visit(node.pattern.predicate)) + guard = builder.unless_guard(token(node.pattern.unless_keyword_loc), visit(node.pattern.predicate)) else pattern = within_pattern { |compiler| node.pattern.accept(compiler) } end builder.in_pattern( - token(node.in_loc), + token(node.in_keyword_loc), pattern, guard, - if (then_loc = node.then_loc) - token(then_loc) + if (then_keyword_loc = node.then_keyword_loc) + token(then_keyword_loc) else srange_semicolon(node.pattern.location.end_offset, node.statements&.location&.start_offset) end, @@ -1296,7 +1296,7 @@ def visit_local_variable_target_node(node) def visit_match_predicate_node(node) builder.match_pattern_p( visit(node.value), - token(node.operator_loc), + token(node.keyword_loc), within_pattern { |compiler| node.pattern.accept(compiler) } ) end @@ -1807,9 +1807,9 @@ def visit_undef_node(node) # bar unless foo # ^^^^^^^^^^^^^^ def visit_unless_node(node) - if node.keyword_loc.start_offset == node.location.start_offset + if node.unless_keyword_loc.start_offset == node.location.start_offset builder.condition( - token(node.keyword_loc), + token(node.unless_keyword_loc), visit(node.predicate), if (then_keyword_loc = node.then_keyword_loc) token(then_keyword_loc) @@ -1825,7 +1825,7 @@ def visit_unless_node(node) builder.condition_mod( visit(node.else_clause), visit(node.statements), - token(node.keyword_loc), + token(node.unless_keyword_loc), visit(node.predicate) ) end @@ -1837,24 +1837,24 @@ def visit_unless_node(node) # bar until foo # ^^^^^^^^^^^^^ def visit_until_node(node) - if node.location.start_offset == node.keyword_loc.start_offset + if node.location.start_offset == node.until_keyword_loc.start_offset builder.loop( :until, - token(node.keyword_loc), + token(node.until_keyword_loc), visit(node.predicate), if (do_keyword_loc = node.do_keyword_loc) token(do_keyword_loc) else - srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset) + srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset) end, visit(node.statements), - token(node.closing_loc) + token(node.end_keyword_loc) ) else builder.loop_mod( :until, visit(node.statements), - token(node.keyword_loc), + token(node.until_keyword_loc), visit(node.predicate) ) end @@ -1864,7 +1864,7 @@ def visit_until_node(node) # ^^^^^^^^^^^^^ def visit_when_node(node) builder.when( - token(node.keyword_loc), + token(node.when_keyword_loc), visit_all(node.conditions), if (then_keyword_loc = node.then_keyword_loc) token(then_keyword_loc) @@ -1881,24 +1881,24 @@ def visit_when_node(node) # bar while foo # ^^^^^^^^^^^^^ def visit_while_node(node) - if node.location.start_offset == node.keyword_loc.start_offset + if node.location.start_offset == node.while_keyword_loc.start_offset builder.loop( :while, - token(node.keyword_loc), + token(node.while_keyword_loc), visit(node.predicate), if (do_keyword_loc = node.do_keyword_loc) token(do_keyword_loc) else - srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset) + srange_semicolon(node.predicate.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset) end, visit(node.statements), - token(node.closing_loc) + token(node.end_keyword_loc) ) else builder.loop_mod( :while, visit(node.statements), - token(node.keyword_loc), + token(node.while_keyword_loc), visit(node.predicate) ) end diff --git a/lib/prism/translation/ripper.rb b/lib/prism/translation/ripper.rb index 2f66bab97e..c2aea0d039 100644 --- a/lib/prism/translation/ripper.rb +++ b/lib/prism/translation/ripper.rb @@ -2169,12 +2169,12 @@ def visit_in_node(node) # This is a special case where we're not going to call on_in directly # because we don't have access to the subsequent. Instead, we'll return # the component parts and let the parent node handle it. - bounds(node.in_loc) + bounds(node.in_keyword_loc) on_kw("in") pattern = visit_pattern_node(node.pattern) - if node.then_loc - bounds(node.then_loc) + if node.then_keyword_loc + bounds(node.then_keyword_loc) on_kw("then") end statements = @@ -2633,7 +2633,7 @@ def visit_match_last_line_node(node) # ^^^^^^^^^^ def visit_match_predicate_node(node) value = visit(node.value) - bounds(node.operator_loc) + bounds(node.keyword_loc) on_kw("in") pattern = on_in(visit_pattern_node(node.pattern), nil, nil) @@ -3430,7 +3430,7 @@ def visit_undef_node(node) # ^^^^^^^^^^^^^^ def visit_unless_node(node) if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset) - bounds(node.keyword_loc) + bounds(node.unless_keyword_loc) on_kw("unless") predicate = visit(node.predicate) if node.then_keyword_loc @@ -3455,7 +3455,7 @@ def visit_unless_node(node) on_unless(predicate, statements, else_clause) else statements = visit(node.statements.body.first) - bounds(node.keyword_loc) + bounds(node.unless_keyword_loc) on_kw("unless") predicate = visit(node.predicate) @@ -3470,7 +3470,7 @@ def visit_unless_node(node) # bar until foo # ^^^^^^^^^^^^^ def visit_until_node(node) - bounds(node.keyword_loc) + bounds(node.until_keyword_loc) on_kw("until") if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset) @@ -3487,8 +3487,8 @@ def visit_until_node(node) visit(node.statements) end - if node.closing_loc - bounds(node.closing_loc) + if node.end_keyword_loc + bounds(node.end_keyword_loc) on_kw("end") end @@ -3509,7 +3509,7 @@ def visit_when_node(node) # This is a special case where we're not going to call on_when directly # because we don't have access to the subsequent. Instead, we'll return # the component parts and let the parent node handle it. - bounds(node.keyword_loc) + bounds(node.when_keyword_loc) on_kw("when") conditions = visit_arguments(node.conditions) @@ -3535,15 +3535,15 @@ def visit_when_node(node) # ^^^^^^^^^^^^^ def visit_while_node(node) if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset) - bounds(node.keyword_loc) + bounds(node.while_keyword_loc) on_kw("while") if node.do_keyword_loc bounds(node.do_keyword_loc) on_kw("do") end predicate = visit(node.predicate) - if node.closing_loc - bounds(node.closing_loc) + if node.end_keyword_loc + bounds(node.end_keyword_loc) on_kw("end") end statements = @@ -3558,7 +3558,7 @@ def visit_while_node(node) on_while(predicate, statements) else statements = visit(node.statements.body.first) - bounds(node.keyword_loc) + bounds(node.while_keyword_loc) on_kw("while") predicate = visit(node.predicate) diff --git a/rbi/generated/prism/dsl.rbi b/rbi/generated/prism/dsl.rbi index 8db47017bb..349f683411 100644 --- a/rbi/generated/prism/dsl.rbi +++ b/rbi/generated/prism/dsl.rbi @@ -346,8 +346,8 @@ module Prism def implicit_rest_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new InNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).returns(InNode) } - def in_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_keyword_loc: Location, then_keyword_loc: ::T.nilable(Location)).returns(InNode) } + def in_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), then_keyword_loc: T.unsafe(nil)); end # Create a new IndexAndWriteNode node. sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexAndWriteNode) } @@ -462,8 +462,8 @@ module Prism def match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end # Create a new MatchPredicateNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).returns(MatchPredicateNode) } - def match_predicate_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, keyword_loc: Location).returns(MatchPredicateNode) } + def match_predicate_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new MatchRequiredNode node. sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).returns(MatchRequiredNode) } @@ -646,20 +646,20 @@ module Prism def undef_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new UnlessNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } - def unless_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, unless_keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } + def unless_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), unless_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new UntilNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } - def until_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, until_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } + def until_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), until_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new WhenNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } - def when_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, when_keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } + def when_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), when_keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new WhileNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } - def while_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, while_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } + def while_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), while_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new XStringNode node. sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String).returns(XStringNode) } diff --git a/rbi/generated/prism/node.rbi b/rbi/generated/prism/node.rbi index 4a7f0749d9..e90fd0c265 100644 --- a/rbi/generated/prism/node.rbi +++ b/rbi/generated/prism/node.rbi @@ -6884,8 +6884,8 @@ module Prism # ^^^^^^^^^^^ class InNode < Node # Initialize a new InNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).void } - def initialize(source, node_id, location, flags, pattern, statements, in_loc, then_loc); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_keyword_loc: Location, then_keyword_loc: ::T.nilable(Location)).void } + def initialize(source, node_id, location, flags, pattern, statements, in_keyword_loc, then_keyword_loc); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -6909,8 +6909,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).returns(InNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_keyword_loc: Location, then_keyword_loc: ::T.nilable(Location)).returns(InNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), then_keyword_loc: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -6937,31 +6937,31 @@ module Prism sig { returns(::T.nilable(StatementsNode)) } def statements; end - # Returns the Location represented by `in_loc`. + # Returns the Location represented by `in_keyword_loc`. sig { returns(Location) } - def in_loc; end + def in_keyword_loc; end - # Save the in_loc location using the given saved source so that + # Save the in_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_in_loc(repository); end + def save_in_keyword_loc(repository); end - # Returns the Location represented by `then_loc`. + # Returns the Location represented by `then_keyword_loc`. sig { returns(::T.nilable(Location)) } - def then_loc; end + def then_keyword_loc; end - # Save the then_loc location using the given saved source so that + # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } - def save_then_loc(repository); end + def save_then_keyword_loc(repository); end - # Slice the location of in_loc from the source. + # Slice the location of in_keyword_loc from the source. sig { returns(String) } - def in; end + def in_keyword; end - # Slice the location of then_loc from the source. + # Slice the location of then_keyword_loc from the source. sig { returns(::T.nilable(String)) } - def then; end + def then_keyword; end sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end @@ -9613,8 +9613,8 @@ module Prism # ^^^^^^^^^^ class MatchPredicateNode < Node # Initialize a new MatchPredicateNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).void } - def initialize(source, node_id, location, flags, value, pattern, operator_loc); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, keyword_loc: Location).void } + def initialize(source, node_id, location, flags, value, pattern, keyword_loc); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -9638,8 +9638,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).returns(MatchPredicateNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, keyword_loc: Location).returns(MatchPredicateNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -9666,18 +9666,18 @@ module Prism sig { returns(Node) } def pattern; end - # Returns the Location represented by `operator_loc`. + # Returns the Location represented by `keyword_loc`. sig { returns(Location) } - def operator_loc; end + def keyword_loc; end - # Save the operator_loc location using the given saved source so that + # Save the keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_operator_loc(repository); end + def save_keyword_loc(repository); end - # Slice the location of operator_loc from the source. + # Slice the location of keyword_loc from the source. sig { returns(String) } - def operator; end + def keyword; end sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end @@ -13473,8 +13473,8 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^^ class UnlessNode < Node # Initialize a new UnlessNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).void } - def initialize(source, node_id, location, flags, keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, unless_keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).void } + def initialize(source, node_id, location, flags, unless_keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -13498,8 +13498,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, unless_keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), unless_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -13526,12 +13526,12 @@ module Prism # bar unless cond # ^^^^^^ sig { returns(Location) } - def keyword_loc; end + def unless_keyword_loc; end - # Save the keyword_loc location using the given saved source so that + # Save the unless_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_keyword_loc(repository); end + def save_unless_keyword_loc(repository); end # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). # @@ -13582,9 +13582,9 @@ module Prism sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end - # Slice the location of keyword_loc from the source. + # Slice the location of unless_keyword_loc from the source. sig { returns(String) } - def keyword; end + def unless_keyword; end # Slice the location of then_keyword_loc from the source. sig { returns(::T.nilable(String)) } @@ -13607,8 +13607,8 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^ class UntilNode < Node # Initialize a new UntilNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } - def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, until_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } + def initialize(source, node_id, location, flags, until_keyword_loc, do_keyword_loc, end_keyword_loc, predicate, statements); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -13632,8 +13632,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, until_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), until_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -13656,14 +13656,14 @@ module Prism sig { returns(T::Boolean) } def begin_modifier?; end - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `until_keyword_loc`. sig { returns(Location) } - def keyword_loc; end + def until_keyword_loc; end - # Save the keyword_loc location using the given saved source so that + # Save the until_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_keyword_loc(repository); end + def save_until_keyword_loc(repository); end # Returns the Location represented by `do_keyword_loc`. sig { returns(::T.nilable(Location)) } @@ -13674,14 +13674,14 @@ module Prism sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_do_keyword_loc(repository); end - # Returns the Location represented by `closing_loc`. + # Returns the Location represented by `end_keyword_loc`. sig { returns(::T.nilable(Location)) } - def closing_loc; end + def end_keyword_loc; end - # Save the closing_loc location using the given saved source so that + # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } - def save_closing_loc(repository); end + def save_end_keyword_loc(repository); end # Returns the `predicate` attribute. sig { returns(Node) } @@ -13691,17 +13691,17 @@ module Prism sig { returns(::T.nilable(StatementsNode)) } def statements; end - # Slice the location of keyword_loc from the source. + # Slice the location of until_keyword_loc from the source. sig { returns(String) } - def keyword; end + def until_keyword; end # Slice the location of do_keyword_loc from the source. sig { returns(::T.nilable(String)) } def do_keyword; end - # Slice the location of closing_loc from the source. + # Slice the location of end_keyword_loc from the source. sig { returns(::T.nilable(String)) } - def closing; end + def end_keyword; end sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end @@ -13715,8 +13715,8 @@ module Prism # end class WhenNode < Node # Initialize a new WhenNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).void } - def initialize(source, node_id, location, flags, keyword_loc, conditions, then_keyword_loc, statements); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, when_keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).void } + def initialize(source, node_id, location, flags, when_keyword_loc, conditions, then_keyword_loc, statements); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -13740,8 +13740,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, when_keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), when_keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -13760,14 +13760,14 @@ module Prism sig { override.returns(String) } def inspect; end - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `when_keyword_loc`. sig { returns(Location) } - def keyword_loc; end + def when_keyword_loc; end - # Save the keyword_loc location using the given saved source so that + # Save the when_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_keyword_loc(repository); end + def save_when_keyword_loc(repository); end # Returns the `conditions` attribute. sig { returns(T::Array[Node]) } @@ -13786,9 +13786,9 @@ module Prism sig { returns(::T.nilable(StatementsNode)) } def statements; end - # Slice the location of keyword_loc from the source. + # Slice the location of when_keyword_loc from the source. sig { returns(String) } - def keyword; end + def when_keyword; end # Slice the location of then_keyword_loc from the source. sig { returns(::T.nilable(String)) } @@ -13807,8 +13807,8 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^ class WhileNode < Node # Initialize a new WhileNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } - def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, while_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } + def initialize(source, node_id, location, flags, while_keyword_loc, do_keyword_loc, end_keyword_loc, predicate, statements); end # See Node.accept. sig { override.params(visitor: Visitor).returns(::T.untyped) } @@ -13832,8 +13832,8 @@ module Prism def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } - def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end + sig { params(node_id: Integer, location: Location, flags: Integer, while_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } + def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), while_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end @@ -13856,14 +13856,14 @@ module Prism sig { returns(T::Boolean) } def begin_modifier?; end - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `while_keyword_loc`. sig { returns(Location) } - def keyword_loc; end + def while_keyword_loc; end - # Save the keyword_loc location using the given saved source so that + # Save the while_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(Relocation::Entry) } - def save_keyword_loc(repository); end + def save_while_keyword_loc(repository); end # Returns the Location represented by `do_keyword_loc`. sig { returns(::T.nilable(Location)) } @@ -13874,14 +13874,14 @@ module Prism sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_do_keyword_loc(repository); end - # Returns the Location represented by `closing_loc`. + # Returns the Location represented by `end_keyword_loc`. sig { returns(::T.nilable(Location)) } - def closing_loc; end + def end_keyword_loc; end - # Save the closing_loc location using the given saved source so that + # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } - def save_closing_loc(repository); end + def save_end_keyword_loc(repository); end # Returns the `predicate` attribute. sig { returns(Node) } @@ -13891,17 +13891,17 @@ module Prism sig { returns(::T.nilable(StatementsNode)) } def statements; end - # Slice the location of keyword_loc from the source. + # Slice the location of while_keyword_loc from the source. sig { returns(String) } - def keyword; end + def while_keyword; end # Slice the location of do_keyword_loc from the source. sig { returns(::T.nilable(String)) } def do_keyword; end - # Slice the location of closing_loc from the source. + # Slice the location of end_keyword_loc from the source. sig { returns(::T.nilable(String)) } - def closing; end + def end_keyword; end sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end diff --git a/rbi/generated/prism/node_ext.rbi b/rbi/generated/prism/node_ext.rbi index c90a6de582..589007ddcc 100644 --- a/rbi/generated/prism/node_ext.rbi +++ b/rbi/generated/prism/node_ext.rbi @@ -182,4 +182,70 @@ module Prism sig { returns(::T.nilable(Location)) } def full_message_loc; end end + + class InNode < Node + sig { returns(String) } + def in; end + + sig { returns(Location) } + def in_loc; end + + sig { returns(::T.nilable(String)) } + def then; end + + sig { returns(::T.nilable(Location)) } + def then_loc; end + end + + class MatchPredicateNode < Node + sig { returns(String) } + def operator; end + + sig { returns(Location) } + def operator_loc; end + end + + class UnlessNode < Node + sig { returns(String) } + def keyword; end + + sig { returns(Location) } + def keyword_loc; end + end + + class UntilNode < Node + sig { returns(String) } + def keyword; end + + sig { returns(Location) } + def keyword_loc; end + + sig { returns(::T.nilable(String)) } + def closing; end + + sig { returns(::T.nilable(Location)) } + def closing_loc; end + end + + class WhenNode < Node + sig { returns(String) } + def keyword; end + + sig { returns(Location) } + def keyword_loc; end + end + + class WhileNode < Node + sig { returns(String) } + def keyword; end + + sig { returns(Location) } + def keyword_loc; end + + sig { returns(::T.nilable(String)) } + def closing; end + + sig { returns(::T.nilable(Location)) } + def closing_loc; end + end end diff --git a/sig/generated/prism/dsl.rbs b/sig/generated/prism/dsl.rbs index 541a87eba4..e26b938317 100644 --- a/sig/generated/prism/dsl.rbs +++ b/sig/generated/prism/dsl.rbs @@ -420,8 +420,8 @@ module Prism # Create a new InNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode - def in_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_keyword_loc: Location, ?then_keyword_loc: Location?) -> InNode + def in_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_keyword_loc: Location, ?then_keyword_loc: Location?) -> InNode # Create a new IndexAndWriteNode node. # -- @@ -565,8 +565,8 @@ module Prism # Create a new MatchPredicateNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode - def match_predicate_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?keyword_loc: Location) -> MatchPredicateNode + def match_predicate_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?keyword_loc: Location) -> MatchPredicateNode # Create a new MatchRequiredNode node. # -- @@ -795,23 +795,23 @@ module Prism # Create a new UnlessNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode - def unless_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?unless_keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode + def unless_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?unless_keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode # Create a new UntilNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode - def until_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?until_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode + def until_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?until_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode # Create a new WhenNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode - def when_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?when_keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode + def when_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?when_keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode # Create a new WhileNode node. # -- - # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode - def while_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode + # : (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?while_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode + def while_node: (?source: Source, ?node_id: Integer, ?location: Location, ?flags: Integer, ?while_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode # Create a new XStringNode node. # -- diff --git a/sig/generated/prism/node.rbs b/sig/generated/prism/node.rbs index 20c46fbd99..e45ba05337 100644 --- a/sig/generated/prism/node.rbs +++ b/sig/generated/prism/node.rbs @@ -10000,9 +10000,9 @@ module Prism # case a; in b then c end # ^^^^^^^^^^^ class InNode < Node - @then_loc: Location? + @then_keyword_loc: Location? - @in_loc: Location + @in_keyword_loc: Location @statements: StatementsNode? @@ -10010,8 +10010,8 @@ module Prism # Initialize a new InNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_keyword_loc, Location? then_keyword_loc) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_keyword_loc, Location? then_keyword_loc) -> void # See Node.accept. # -- @@ -10045,8 +10045,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_keyword_loc: Location, ?then_keyword_loc: Location?) -> InNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_keyword_loc: Location, ?then_keyword_loc: Location?) -> InNode alias deconstruct child_nodes @@ -10084,51 +10084,51 @@ module Prism # :category: Locations # :call-seq: - # in_loc -> Location + # in_keyword_loc -> Location # - # Returns the Location represented by `in_loc`. + # Returns the Location represented by `in_keyword_loc`. # -- # : () -> Location - def in_loc: () -> Location + def in_keyword_loc: () -> Location # :category: Repository - # Save the in_loc location using the given saved source so that + # Save the in_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_in_loc: (_Repository repository) -> Relocation::Entry + def save_in_keyword_loc: (_Repository repository) -> Relocation::Entry # :category: Locations # :call-seq: - # then_loc -> Location | nil + # then_keyword_loc -> Location | nil # - # Returns the Location represented by `then_loc`. + # Returns the Location represented by `then_keyword_loc`. # -- # : () -> Location? - def then_loc: () -> Location? + def then_keyword_loc: () -> Location? # :category: Repository - # Save the then_loc location using the given saved source so that + # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry? - def save_then_loc: (_Repository repository) -> Relocation::Entry? + def save_then_keyword_loc: (_Repository repository) -> Relocation::Entry? # :call-seq: - # in -> String + # in_keyword -> String # - # Slice the location of in_loc from the source. + # Slice the location of in_keyword_loc from the source. # -- # : () -> String - def in: () -> String + def in_keyword: () -> String # :call-seq: - # then -> String | nil + # then_keyword -> String | nil # - # Slice the location of then_loc from the source. + # Slice the location of then_keyword_loc from the source. # -- # : () -> String? - def then: () -> String? + def then_keyword: () -> String? # : (untyped other) -> boolish def ===: (untyped other) -> boolish @@ -14141,7 +14141,7 @@ module Prism # foo in bar # ^^^^^^^^^^ class MatchPredicateNode < Node - @operator_loc: Location + @keyword_loc: Location @pattern: Prism::node @@ -14149,8 +14149,8 @@ module Prism # Initialize a new MatchPredicateNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location keyword_loc) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location keyword_loc) -> void # See Node.accept. # -- @@ -14184,8 +14184,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?keyword_loc: Location) -> MatchPredicateNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?keyword_loc: Location) -> MatchPredicateNode alias deconstruct child_nodes @@ -14223,27 +14223,27 @@ module Prism # :category: Locations # :call-seq: - # operator_loc -> Location + # keyword_loc -> Location # - # Returns the Location represented by `operator_loc`. + # Returns the Location represented by `keyword_loc`. # -- # : () -> Location - def operator_loc: () -> Location + def keyword_loc: () -> Location # :category: Repository - # Save the operator_loc location using the given saved source so that + # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_operator_loc: (_Repository repository) -> Relocation::Entry + def save_keyword_loc: (_Repository repository) -> Relocation::Entry # :call-seq: - # operator -> String + # keyword -> String # - # Slice the location of operator_loc from the source. + # Slice the location of keyword_loc from the source. # -- # : () -> String - def operator: () -> String + def keyword: () -> String # : (untyped other) -> boolish def ===: (untyped other) -> boolish @@ -19749,12 +19749,12 @@ module Prism @predicate: Prism::node - @keyword_loc: Location + @unless_keyword_loc: Location # Initialize a new UnlessNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Location unless_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Location unless_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void # See Node.accept. # -- @@ -19788,8 +19788,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?unless_keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?unless_keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode alias deconstruct child_nodes @@ -19811,7 +19811,7 @@ module Prism # :category: Locations # :call-seq: - # keyword_loc -> Location + # unless_keyword_loc -> Location # # The Location of the `unless` keyword. # @@ -19822,14 +19822,14 @@ module Prism # ^^^^^^ # -- # : () -> Location - def keyword_loc: () -> Location + def unless_keyword_loc: () -> Location # :category: Repository - # Save the keyword_loc location using the given saved source so that + # Save the unless_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_keyword_loc: (_Repository repository) -> Relocation::Entry + def save_unless_keyword_loc: (_Repository repository) -> Relocation::Entry # :call-seq: # predicate -> Node @@ -19907,12 +19907,12 @@ module Prism def save_end_keyword_loc: (_Repository repository) -> Relocation::Entry? # :call-seq: - # keyword -> String + # unless_keyword -> String # - # Slice the location of keyword_loc from the source. + # Slice the location of unless_keyword_loc from the source. # -- # : () -> String - def keyword: () -> String + def unless_keyword: () -> String # :call-seq: # then_keyword -> String | nil @@ -19946,16 +19946,16 @@ module Prism @predicate: Prism::node - @closing_loc: Location? + @end_keyword_loc: Location? @do_keyword_loc: Location? - @keyword_loc: Location + @until_keyword_loc: Location # Initialize a new UntilNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Location until_keyword_loc, Location? do_keyword_loc, Location? end_keyword_loc, Prism::node predicate, StatementsNode? statements) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Location until_keyword_loc, Location? do_keyword_loc, Location? end_keyword_loc, Prism::node predicate, StatementsNode? statements) -> void # See Node.accept. # -- @@ -19989,8 +19989,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?until_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?until_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode alias deconstruct child_nodes @@ -20018,19 +20018,19 @@ module Prism # :category: Locations # :call-seq: - # keyword_loc -> Location + # until_keyword_loc -> Location # - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `until_keyword_loc`. # -- # : () -> Location - def keyword_loc: () -> Location + def until_keyword_loc: () -> Location # :category: Repository - # Save the keyword_loc location using the given saved source so that + # Save the until_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_keyword_loc: (_Repository repository) -> Relocation::Entry + def save_until_keyword_loc: (_Repository repository) -> Relocation::Entry # :category: Locations # :call-seq: @@ -20050,19 +20050,19 @@ module Prism # :category: Locations # :call-seq: - # closing_loc -> Location | nil + # end_keyword_loc -> Location | nil # - # Returns the Location represented by `closing_loc`. + # Returns the Location represented by `end_keyword_loc`. # -- # : () -> Location? - def closing_loc: () -> Location? + def end_keyword_loc: () -> Location? # :category: Repository - # Save the closing_loc location using the given saved source so that + # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry? - def save_closing_loc: (_Repository repository) -> Relocation::Entry? + def save_end_keyword_loc: (_Repository repository) -> Relocation::Entry? # :call-seq: # predicate -> Node @@ -20081,12 +20081,12 @@ module Prism def statements: () -> StatementsNode? # :call-seq: - # keyword -> String + # until_keyword -> String # - # Slice the location of keyword_loc from the source. + # Slice the location of until_keyword_loc from the source. # -- # : () -> String - def keyword: () -> String + def until_keyword: () -> String # :call-seq: # do_keyword -> String | nil @@ -20097,12 +20097,12 @@ module Prism def do_keyword: () -> String? # :call-seq: - # closing -> String | nil + # end_keyword -> String | nil # - # Slice the location of closing_loc from the source. + # Slice the location of end_keyword_loc from the source. # -- # : () -> String? - def closing: () -> String? + def end_keyword: () -> String? # : (untyped other) -> boolish def ===: (untyped other) -> boolish @@ -20121,12 +20121,12 @@ module Prism @conditions: Array[Prism::node] - @keyword_loc: Location + @when_keyword_loc: Location # Initialize a new WhenNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Location when_keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Location when_keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void # See Node.accept. # -- @@ -20160,8 +20160,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?when_keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?when_keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode alias deconstruct child_nodes @@ -20183,19 +20183,19 @@ module Prism # :category: Locations # :call-seq: - # keyword_loc -> Location + # when_keyword_loc -> Location # - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `when_keyword_loc`. # -- # : () -> Location - def keyword_loc: () -> Location + def when_keyword_loc: () -> Location # :category: Repository - # Save the keyword_loc location using the given saved source so that + # Save the when_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_keyword_loc: (_Repository repository) -> Relocation::Entry + def save_when_keyword_loc: (_Repository repository) -> Relocation::Entry # :call-seq: # conditions -> Array[Node] @@ -20230,12 +20230,12 @@ module Prism def statements: () -> StatementsNode? # :call-seq: - # keyword -> String + # when_keyword -> String # - # Slice the location of keyword_loc from the source. + # Slice the location of when_keyword_loc from the source. # -- # : () -> String - def keyword: () -> String + def when_keyword: () -> String # :call-seq: # then_keyword -> String | nil @@ -20261,16 +20261,16 @@ module Prism @predicate: Prism::node - @closing_loc: Location? + @end_keyword_loc: Location? @do_keyword_loc: Location? - @keyword_loc: Location + @while_keyword_loc: Location # Initialize a new WhileNode node. # -- - # : (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void - def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void + # : (Source source, Integer node_id, Location location, Integer flags, Location while_keyword_loc, Location? do_keyword_loc, Location? end_keyword_loc, Prism::node predicate, StatementsNode? statements) -> void + def initialize: (Source source, Integer node_id, Location location, Integer flags, Location while_keyword_loc, Location? do_keyword_loc, Location? end_keyword_loc, Prism::node predicate, StatementsNode? statements) -> void # See Node.accept. # -- @@ -20304,8 +20304,8 @@ module Prism # # Creates a copy of self with the given fields, using self as the template. # -- - # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode - def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode + # : (?node_id: Integer, ?location: Location, ?flags: Integer, ?while_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode + def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?while_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode alias deconstruct child_nodes @@ -20333,19 +20333,19 @@ module Prism # :category: Locations # :call-seq: - # keyword_loc -> Location + # while_keyword_loc -> Location # - # Returns the Location represented by `keyword_loc`. + # Returns the Location represented by `while_keyword_loc`. # -- # : () -> Location - def keyword_loc: () -> Location + def while_keyword_loc: () -> Location # :category: Repository - # Save the keyword_loc location using the given saved source so that + # Save the while_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry - def save_keyword_loc: (_Repository repository) -> Relocation::Entry + def save_while_keyword_loc: (_Repository repository) -> Relocation::Entry # :category: Locations # :call-seq: @@ -20365,19 +20365,19 @@ module Prism # :category: Locations # :call-seq: - # closing_loc -> Location | nil + # end_keyword_loc -> Location | nil # - # Returns the Location represented by `closing_loc`. + # Returns the Location represented by `end_keyword_loc`. # -- # : () -> Location? - def closing_loc: () -> Location? + def end_keyword_loc: () -> Location? # :category: Repository - # Save the closing_loc location using the given saved source so that + # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # -- # : (_Repository repository) -> Relocation::Entry? - def save_closing_loc: (_Repository repository) -> Relocation::Entry? + def save_end_keyword_loc: (_Repository repository) -> Relocation::Entry? # :call-seq: # predicate -> Node @@ -20396,12 +20396,12 @@ module Prism def statements: () -> StatementsNode? # :call-seq: - # keyword -> String + # while_keyword -> String # - # Slice the location of keyword_loc from the source. + # Slice the location of while_keyword_loc from the source. # -- # : () -> String - def keyword: () -> String + def while_keyword: () -> String # :call-seq: # do_keyword -> String | nil @@ -20412,12 +20412,12 @@ module Prism def do_keyword: () -> String? # :call-seq: - # closing -> String | nil + # end_keyword -> String | nil # - # Slice the location of closing_loc from the source. + # Slice the location of end_keyword_loc from the source. # -- # : () -> String? - def closing: () -> String? + def end_keyword: () -> String? # : (untyped other) -> boolish def ===: (untyped other) -> boolish diff --git a/sig/generated/prism/node_ext.rbs b/sig/generated/prism/node_ext.rbs index dabcdb0590..be8cc59abc 100644 --- a/sig/generated/prism/node_ext.rbs +++ b/sig/generated/prism/node_ext.rbs @@ -212,4 +212,70 @@ module Prism # : () -> Location? def full_message_loc: () -> Location? end + + class InNode < Node + # : () -> String + def in: () -> String + + # : () -> Location + def in_loc: () -> Location + + # : () -> String? + def then: () -> String? + + # : () -> Location? + def then_loc: () -> Location? + end + + class MatchPredicateNode < Node + # : () -> String + def operator: () -> String + + # : () -> Location + def operator_loc: () -> Location + end + + class UnlessNode < Node + # : () -> String + def keyword: () -> String + + # : () -> Location + def keyword_loc: () -> Location + end + + class UntilNode < Node + # : () -> String + def keyword: () -> String + + # : () -> Location + def keyword_loc: () -> Location + + # : () -> String? + def closing: () -> String? + + # : () -> Location? + def closing_loc: () -> Location? + end + + class WhenNode < Node + # : () -> String + def keyword: () -> String + + # : () -> Location + def keyword_loc: () -> Location + end + + class WhileNode < Node + # : () -> String + def keyword: () -> String + + # : () -> Location + def keyword_loc: () -> Location + + # : () -> String? + def closing: () -> String? + + # : () -> Location? + def closing_loc: () -> Location? + end end diff --git a/snapshots/3.3-4.0/void_value.txt b/snapshots/3.3-4.0/void_value.txt index b5f501cd40..58e1e27b44 100644 --- a/snapshots/3.3-4.0/void_value.txt +++ b/snapshots/3.3-4.0/void_value.txt @@ -74,7 +74,7 @@ │ │ ├── conditions: (length: 1) │ │ │ └── @ WhenNode (location: (10,2)-(10,20)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (10,2)-(10,6) = "when" + │ │ │ ├── when_keyword_loc: (10,2)-(10,6) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ IntegerNode (location: (10,7)-(10,8)) │ │ │ │ ├── flags: static_literal, decimal @@ -131,8 +131,8 @@ │ │ │ │ ├── flags: newline │ │ │ │ ├── keyword_loc: (15,12)-(15,18) = "return" │ │ │ │ └── arguments: ∅ - │ │ │ ├── in_loc: (15,2)-(15,4) = "in" - │ │ │ └── then_loc: (15,7)-(15,11) = "then" + │ │ │ ├── in_keyword_loc: (15,2)-(15,4) = "in" + │ │ │ └── then_keyword_loc: (15,7)-(15,11) = "then" │ │ ├── else_clause: │ │ │ @ ElseNode (location: (16,2)-(17,3)) │ │ │ ├── flags: ∅ diff --git a/snapshots/break.txt b/snapshots/break.txt index df29276b90..745d7d0d2d 100644 --- a/snapshots/break.txt +++ b/snapshots/break.txt @@ -556,9 +556,9 @@ │ └── block: ∅ ├── @ WhileNode (location: (31,0)-(31,21)) │ ├── flags: newline - │ ├── keyword_loc: (31,0)-(31,5) = "while" + │ ├── while_keyword_loc: (31,0)-(31,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (31,18)-(31,21) = "end" + │ ├── end_keyword_loc: (31,18)-(31,21) = "end" │ ├── predicate: │ │ @ AndNode (location: (31,6)-(31,16)) │ │ ├── flags: ∅ @@ -583,9 +583,9 @@ │ └── statements: ∅ └── @ UntilNode (location: (33,0)-(33,21)) ├── flags: newline - ├── keyword_loc: (33,0)-(33,5) = "until" + ├── until_keyword_loc: (33,0)-(33,5) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: (33,18)-(33,21) = "end" + ├── end_keyword_loc: (33,18)-(33,21) = "end" ├── predicate: │ @ AndNode (location: (33,6)-(33,16)) │ ├── flags: ∅ diff --git a/snapshots/case.txt b/snapshots/case.txt index 5a569ad6cf..0052b7aa43 100644 --- a/snapshots/case.txt +++ b/snapshots/case.txt @@ -17,7 +17,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (2,0)-(2,8)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (2,0)-(2,4) = "when" + │ │ ├── when_keyword_loc: (2,0)-(2,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (2,5)-(2,8)) │ │ │ ├── flags: static_literal, forced_us_ascii_encoding @@ -38,7 +38,7 @@ │ ├── conditions: (length: 2) │ │ ├── @ WhenNode (location: (5,11)-(5,30)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (5,11)-(5,15) = "when" + │ │ │ ├── when_keyword_loc: (5,11)-(5,15) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ TrueNode (location: (5,16)-(5,20)) │ │ │ │ └── flags: static_literal @@ -69,7 +69,7 @@ │ │ │ └── block: ∅ │ │ └── @ WhenNode (location: (5,32)-(5,53)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (5,32)-(5,36) = "when" + │ │ ├── when_keyword_loc: (5,32)-(5,36) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ FalseNode (location: (5,37)-(5,42)) │ │ │ └── flags: static_literal @@ -107,7 +107,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (7,6)-(7,15)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (7,6)-(7,10) = "when" + │ │ ├── when_keyword_loc: (7,6)-(7,10) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SplatNode (location: (7,11)-(7,15)) │ │ │ ├── flags: ∅ @@ -141,7 +141,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (10,0)-(10,8)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (10,0)-(10,4) = "when" + │ │ ├── when_keyword_loc: (10,0)-(10,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (10,5)-(10,8)) │ │ │ ├── flags: static_literal, forced_us_ascii_encoding @@ -185,7 +185,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (15,11)-(15,31)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (15,11)-(15,15) = "when" + │ │ ├── when_keyword_loc: (15,11)-(15,15) = "when" │ │ ├── conditions: (length: 2) │ │ │ ├── @ ConstantReadNode (location: (15,16)-(15,22)) │ │ │ │ ├── flags: ∅ @@ -204,7 +204,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (18,0)-(18,15)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (18,0)-(18,4) = "when" + │ │ ├── when_keyword_loc: (18,0)-(18,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (18,5)-(18,15)) │ │ │ ├── flags: ∅ @@ -253,7 +253,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (22,0)-(22,6)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (22,0)-(22,4) = "when" + │ │ ├── when_keyword_loc: (22,0)-(22,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (22,5)-(22,6)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -293,7 +293,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (28,3)-(28,10)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (28,3)-(28,7) = "when" + │ │ ├── when_keyword_loc: (28,3)-(28,7) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SymbolNode (location: (28,8)-(28,10)) │ │ │ ├── flags: static_literal, forced_us_ascii_encoding @@ -317,7 +317,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (32,14)-(32,20)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (32,14)-(32,18) = "when" + │ │ ├── when_keyword_loc: (32,14)-(32,18) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ IntegerNode (location: (32,19)-(32,20)) │ │ │ ├── flags: static_literal, decimal @@ -340,11 +340,11 @@ │ │ │ @ IntegerNode (location: (34,10)-(34,11)) │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 2 - │ │ └── operator_loc: (34,7)-(34,9) = "in" + │ │ └── keyword_loc: (34,7)-(34,9) = "in" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (35,0)-(35,6)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (35,0)-(35,4) = "when" + │ │ ├── when_keyword_loc: (35,0)-(35,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ IntegerNode (location: (35,5)-(35,6)) │ │ │ ├── flags: static_literal, decimal @@ -367,11 +367,11 @@ │ │ │ @ IntegerNode (location: (38,10)-(38,11)) │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 2 - │ │ └── operator_loc: (38,7)-(38,9) = "in" + │ │ └── keyword_loc: (38,7)-(38,9) = "in" │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (38,13)-(38,19)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (38,13)-(38,17) = "when" + │ │ ├── when_keyword_loc: (38,13)-(38,17) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ IntegerNode (location: (38,18)-(38,19)) │ │ │ ├── flags: static_literal, decimal @@ -394,7 +394,7 @@ │ │ │ @ IntegerNode (location: (40,10)-(40,11)) │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 2 - │ │ └── operator_loc: (40,7)-(40,9) = "in" + │ │ └── keyword_loc: (40,7)-(40,9) = "in" │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (41,0)-(41,4)) │ │ ├── flags: ∅ @@ -403,8 +403,8 @@ │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 3 │ │ ├── statements: ∅ - │ │ ├── in_loc: (41,0)-(41,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (41,0)-(41,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (40,0)-(40,4) = "case" │ └── end_keyword_loc: (42,0)-(42,3) = "end" @@ -421,7 +421,7 @@ │ │ │ @ IntegerNode (location: (44,10)-(44,11)) │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 2 - │ │ └── operator_loc: (44,7)-(44,9) = "in" + │ │ └── keyword_loc: (44,7)-(44,9) = "in" │ ├── conditions: (length: 1) │ │ └── @ InNode (location: (44,13)-(44,17)) │ │ ├── flags: ∅ @@ -430,8 +430,8 @@ │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 3 │ │ ├── statements: ∅ - │ │ ├── in_loc: (44,13)-(44,15) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (44,13)-(44,15) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (44,0)-(44,4) = "case" │ └── end_keyword_loc: (44,19)-(44,22) = "end" @@ -510,8 +510,8 @@ │ │ │ ├── closing_loc: ∅ │ │ │ ├── equal_loc: ∅ │ │ │ └── block: ∅ - │ │ ├── in_loc: (47,0)-(47,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (47,0)-(47,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (46,0)-(46,4) = "case" │ └── end_keyword_loc: (49,0)-(49,3) = "end" @@ -559,8 +559,8 @@ │ │ │ │ └── depth: 0 │ │ │ └── operator_loc: (53,5)-(53,6) = "^" │ │ ├── statements: ∅ - │ │ ├── in_loc: (53,2)-(53,4) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (53,2)-(53,4) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (52,2)-(52,6) = "case" │ └── end_keyword_loc: (54,2)-(54,5) = "end" diff --git a/snapshots/case_in_hash_key.txt b/snapshots/case_in_hash_key.txt index db6811b8dc..480252bd12 100644 --- a/snapshots/case_in_hash_key.txt +++ b/snapshots/case_in_hash_key.txt @@ -67,8 +67,8 @@ │ │ │ ├── closing_loc: ∅ │ │ │ ├── equal_loc: ∅ │ │ │ └── block: ∅ - │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ └── then_keyword_loc: ∅ │ └── @ InNode (location: (4,0)-(5,18)) │ ├── flags: ∅ │ ├── pattern: @@ -124,8 +124,8 @@ │ │ ├── closing_loc: ∅ │ │ ├── equal_loc: ∅ │ │ └── block: ∅ - │ ├── in_loc: (4,0)-(4,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (4,0)-(4,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (6,0)-(6,3) = "end" diff --git a/snapshots/case_in_in.txt b/snapshots/case_in_in.txt index 0fcedb0e89..a993bff160 100644 --- a/snapshots/case_in_in.txt +++ b/snapshots/case_in_in.txt @@ -73,9 +73,9 @@ │ │ │ │ ├── name: :event │ │ │ │ └── depth: 0 │ │ │ └── operator_loc: (3,19)-(3,20) = "^" - │ │ └── operator_loc: (3,16)-(3,18) = "in" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ │ └── keyword_loc: (3,16)-(3,18) = "in" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/command_method_call.txt b/snapshots/command_method_call.txt index 772484a117..d9f2099d99 100644 --- a/snapshots/command_method_call.txt +++ b/snapshots/command_method_call.txt @@ -100,7 +100,7 @@ │ └── end_keyword_loc: ∅ ├── @ UnlessNode (location: (7,0)-(7,18)) │ ├── flags: newline - │ ├── keyword_loc: (7,6)-(7,12) = "unless" + │ ├── unless_keyword_loc: (7,6)-(7,12) = "unless" │ ├── predicate: │ │ @ CallNode (location: (7,13)-(7,18)) │ │ ├── flags: ignore_visibility @@ -145,9 +145,9 @@ │ └── end_keyword_loc: ∅ ├── @ WhileNode (location: (9,0)-(9,17)) │ ├── flags: newline - │ ├── keyword_loc: (9,6)-(9,11) = "while" + │ ├── while_keyword_loc: (9,6)-(9,11) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (9,12)-(9,17)) │ │ ├── flags: ignore_visibility @@ -189,9 +189,9 @@ │ └── block: ∅ ├── @ UntilNode (location: (11,0)-(11,17)) │ ├── flags: newline - │ ├── keyword_loc: (11,6)-(11,11) = "until" + │ ├── until_keyword_loc: (11,6)-(11,11) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (11,12)-(11,17)) │ │ ├── flags: ignore_visibility diff --git a/snapshots/if.txt b/snapshots/if.txt index fce59fd80c..721b4ed2e6 100644 --- a/snapshots/if.txt +++ b/snapshots/if.txt @@ -435,7 +435,7 @@ │ │ │ @ IntegerNode (location: (29,11)-(29,12)) │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 1 - │ │ └── operator_loc: (29,8)-(29,10) = "in" + │ │ └── keyword_loc: (29,8)-(29,10) = "in" │ ├── then_keyword_loc: ∅ │ ├── statements: ∅ │ ├── subsequent: @@ -461,7 +461,7 @@ │ │ │ │ @ ConstantReadNode (location: (30,14)-(30,15)) │ │ │ │ ├── flags: ∅ │ │ │ │ └── name: :B - │ │ │ └── operator_loc: (30,11)-(30,13) = "in" + │ │ │ └── keyword_loc: (30,11)-(30,13) = "in" │ │ ├── then_keyword_loc: ∅ │ │ ├── statements: ∅ │ │ ├── subsequent: ∅ diff --git a/snapshots/method_calls.txt b/snapshots/method_calls.txt index 31389341ed..126d06bb44 100644 --- a/snapshots/method_calls.txt +++ b/snapshots/method_calls.txt @@ -2173,9 +2173,9 @@ │ │ │ └── unescaped: "a" │ │ ├── @ WhileNode (location: (127,2)-(131,5)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (127,2)-(127,7) = "while" + │ │ │ ├── while_keyword_loc: (127,2)-(127,7) = "while" │ │ │ ├── do_keyword_loc: ∅ - │ │ │ ├── closing_loc: (131,2)-(131,5) = "end" + │ │ │ ├── end_keyword_loc: (131,2)-(131,5) = "end" │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (127,8)-(127,9)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -2237,9 +2237,9 @@ │ │ │ └── closing_loc: (130,4)-(130,7) = "end" │ │ └── @ UntilNode (location: (132,2)-(135,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (132,2)-(132,7) = "until" + │ │ ├── until_keyword_loc: (132,2)-(132,7) = "until" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (135,2)-(135,5) = "end" + │ │ ├── end_keyword_loc: (135,2)-(135,5) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (132,8)-(132,9)) │ │ │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/non_void_value.txt b/snapshots/non_void_value.txt index 8e7ab3e75f..0b8b2740fa 100644 --- a/snapshots/non_void_value.txt +++ b/snapshots/non_void_value.txt @@ -237,7 +237,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (26,2)-(28,17)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (26,2)-(26,6) = "when" + │ │ ├── when_keyword_loc: (26,2)-(26,6) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ IntegerNode (location: (26,7)-(26,8)) │ │ │ ├── flags: static_literal, decimal diff --git a/snapshots/patterns.txt b/snapshots/patterns.txt index 20c9b1f994..a35760f804 100644 --- a/snapshots/patterns.txt +++ b/snapshots/patterns.txt @@ -2745,7 +2745,7 @@ │ │ ├── flags: ∅ │ │ ├── name: :bar │ │ └── depth: 0 - │ └── operator_loc: (101,4)-(101,6) = "in" + │ └── keyword_loc: (101,4)-(101,6) = "in" ├── @ MatchPredicateNode (location: (102,0)-(102,8)) │ ├── flags: newline │ ├── value: @@ -2764,7 +2764,7 @@ │ │ @ IntegerNode (location: (102,7)-(102,8)) │ │ ├── flags: static_literal, decimal │ │ └── value: 1 - │ └── operator_loc: (102,4)-(102,6) = "in" + │ └── keyword_loc: (102,4)-(102,6) = "in" ├── @ MatchPredicateNode (location: (103,0)-(103,10)) │ ├── flags: newline │ ├── value: @@ -2783,7 +2783,7 @@ │ │ @ FloatNode (location: (103,7)-(103,10)) │ │ ├── flags: static_literal │ │ └── value: 1.0 - │ └── operator_loc: (103,4)-(103,6) = "in" + │ └── keyword_loc: (103,4)-(103,6) = "in" ├── @ MatchPredicateNode (location: (104,0)-(104,9)) │ ├── flags: newline │ ├── value: @@ -2805,7 +2805,7 @@ │ │ @ IntegerNode (location: (104,7)-(104,8)) │ │ ├── flags: static_literal, decimal │ │ └── value: 1 - │ └── operator_loc: (104,4)-(104,6) = "in" + │ └── keyword_loc: (104,4)-(104,6) = "in" ├── @ MatchPredicateNode (location: (105,0)-(105,9)) │ ├── flags: newline │ ├── value: @@ -2825,7 +2825,7 @@ │ │ ├── flags: static_literal, decimal │ │ ├── numerator: 1 │ │ └── denominator: 1 - │ └── operator_loc: (105,4)-(105,6) = "in" + │ └── keyword_loc: (105,4)-(105,6) = "in" ├── @ MatchPredicateNode (location: (106,0)-(106,11)) │ ├── flags: newline │ ├── value: @@ -2847,7 +2847,7 @@ │ │ ├── value_loc: (106,8)-(106,11) = "foo" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "foo" - │ └── operator_loc: (106,4)-(106,6) = "in" + │ └── keyword_loc: (106,4)-(106,6) = "in" ├── @ MatchPredicateNode (location: (107,0)-(107,14)) │ ├── flags: newline │ ├── value: @@ -2869,7 +2869,7 @@ │ │ ├── value_loc: (107,10)-(107,13) = "foo" │ │ ├── closing_loc: (107,13)-(107,14) = "]" │ │ └── unescaped: "foo" - │ └── operator_loc: (107,4)-(107,6) = "in" + │ └── keyword_loc: (107,4)-(107,6) = "in" ├── @ MatchPredicateNode (location: (108,0)-(108,13)) │ ├── flags: newline │ ├── value: @@ -2891,7 +2891,7 @@ │ │ ├── value_loc: (108,9)-(108,12) = "foo" │ │ ├── closing_loc: (108,12)-(108,13) = "\"" │ │ └── unescaped: "foo" - │ └── operator_loc: (108,4)-(108,6) = "in" + │ └── keyword_loc: (108,4)-(108,6) = "in" ├── @ MatchPredicateNode (location: (109,0)-(109,12)) │ ├── flags: newline │ ├── value: @@ -2913,7 +2913,7 @@ │ │ ├── content_loc: (109,8)-(109,11) = "foo" │ │ ├── closing_loc: (109,11)-(109,12) = "/" │ │ └── unescaped: "foo" - │ └── operator_loc: (109,4)-(109,6) = "in" + │ └── keyword_loc: (109,4)-(109,6) = "in" ├── @ MatchPredicateNode (location: (110,0)-(110,12)) │ ├── flags: newline │ ├── value: @@ -2935,7 +2935,7 @@ │ │ ├── content_loc: (110,8)-(110,11) = "foo" │ │ ├── closing_loc: (110,11)-(110,12) = "`" │ │ └── unescaped: "foo" - │ └── operator_loc: (110,4)-(110,6) = "in" + │ └── keyword_loc: (110,4)-(110,6) = "in" ├── @ MatchPredicateNode (location: (111,0)-(111,14)) │ ├── flags: newline │ ├── value: @@ -2957,7 +2957,7 @@ │ │ ├── content_loc: (111,10)-(111,13) = "foo" │ │ ├── closing_loc: (111,13)-(111,14) = "]" │ │ └── unescaped: "foo" - │ └── operator_loc: (111,4)-(111,6) = "in" + │ └── keyword_loc: (111,4)-(111,6) = "in" ├── @ MatchPredicateNode (location: (112,0)-(112,14)) │ ├── flags: newline │ ├── value: @@ -2984,7 +2984,7 @@ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (112,7)-(112,10) = "%i[" │ │ └── closing_loc: (112,13)-(112,14) = "]" - │ └── operator_loc: (112,4)-(112,6) = "in" + │ └── keyword_loc: (112,4)-(112,6) = "in" ├── @ MatchPredicateNode (location: (113,0)-(113,14)) │ ├── flags: newline │ ├── value: @@ -3011,7 +3011,7 @@ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (113,7)-(113,10) = "%I[" │ │ └── closing_loc: (113,13)-(113,14) = "]" - │ └── operator_loc: (113,4)-(113,6) = "in" + │ └── keyword_loc: (113,4)-(113,6) = "in" ├── @ MatchPredicateNode (location: (114,0)-(114,14)) │ ├── flags: newline │ ├── value: @@ -3038,7 +3038,7 @@ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (114,7)-(114,10) = "%w[" │ │ └── closing_loc: (114,13)-(114,14) = "]" - │ └── operator_loc: (114,4)-(114,6) = "in" + │ └── keyword_loc: (114,4)-(114,6) = "in" ├── @ MatchPredicateNode (location: (115,0)-(115,14)) │ ├── flags: newline │ ├── value: @@ -3065,7 +3065,7 @@ │ │ │ └── unescaped: "foo" │ │ ├── opening_loc: (115,7)-(115,10) = "%W[" │ │ └── closing_loc: (115,13)-(115,14) = "]" - │ └── operator_loc: (115,4)-(115,6) = "in" + │ └── keyword_loc: (115,4)-(115,6) = "in" ├── @ MatchPredicateNode (location: (116,0)-(116,14)) │ ├── flags: newline │ ├── value: @@ -3087,7 +3087,7 @@ │ │ ├── content_loc: (116,10)-(116,13) = "foo" │ │ ├── closing_loc: (116,13)-(116,14) = "]" │ │ └── unescaped: "foo" - │ └── operator_loc: (116,4)-(116,6) = "in" + │ └── keyword_loc: (116,4)-(116,6) = "in" ├── @ MatchPredicateNode (location: (117,0)-(117,14)) │ ├── flags: newline │ ├── value: @@ -3109,7 +3109,7 @@ │ │ ├── content_loc: (117,10)-(117,13) = "foo" │ │ ├── closing_loc: (117,13)-(117,14) = "]" │ │ └── unescaped: "foo" - │ └── operator_loc: (117,4)-(117,6) = "in" + │ └── keyword_loc: (117,4)-(117,6) = "in" ├── @ MatchPredicateNode (location: (118,0)-(118,12)) │ ├── flags: newline │ ├── value: @@ -3131,7 +3131,7 @@ │ │ ├── content_loc: (118,8)-(118,11) = "foo" │ │ ├── closing_loc: (118,11)-(118,12) = "\"" │ │ └── unescaped: "foo" - │ └── operator_loc: (118,4)-(118,6) = "in" + │ └── keyword_loc: (118,4)-(118,6) = "in" ├── @ MatchPredicateNode (location: (119,0)-(119,10)) │ ├── flags: newline │ ├── value: @@ -3149,7 +3149,7 @@ │ ├── pattern: │ │ @ NilNode (location: (119,7)-(119,10)) │ │ └── flags: static_literal - │ └── operator_loc: (119,4)-(119,6) = "in" + │ └── keyword_loc: (119,4)-(119,6) = "in" ├── @ MatchPredicateNode (location: (120,0)-(120,11)) │ ├── flags: newline │ ├── value: @@ -3167,7 +3167,7 @@ │ ├── pattern: │ │ @ SelfNode (location: (120,7)-(120,11)) │ │ └── flags: ∅ - │ └── operator_loc: (120,4)-(120,6) = "in" + │ └── keyword_loc: (120,4)-(120,6) = "in" ├── @ MatchPredicateNode (location: (121,0)-(121,11)) │ ├── flags: newline │ ├── value: @@ -3185,7 +3185,7 @@ │ ├── pattern: │ │ @ TrueNode (location: (121,7)-(121,11)) │ │ └── flags: static_literal - │ └── operator_loc: (121,4)-(121,6) = "in" + │ └── keyword_loc: (121,4)-(121,6) = "in" ├── @ MatchPredicateNode (location: (122,0)-(122,12)) │ ├── flags: newline │ ├── value: @@ -3203,7 +3203,7 @@ │ ├── pattern: │ │ @ FalseNode (location: (122,7)-(122,12)) │ │ └── flags: static_literal - │ └── operator_loc: (122,4)-(122,6) = "in" + │ └── keyword_loc: (122,4)-(122,6) = "in" ├── @ MatchPredicateNode (location: (123,0)-(123,15)) │ ├── flags: newline │ ├── value: @@ -3222,7 +3222,7 @@ │ │ @ SourceFileNode (location: (123,7)-(123,15)) │ │ ├── flags: ∅ │ │ └── filepath: "patterns.txt" - │ └── operator_loc: (123,4)-(123,6) = "in" + │ └── keyword_loc: (123,4)-(123,6) = "in" ├── @ MatchPredicateNode (location: (124,0)-(124,15)) │ ├── flags: newline │ ├── value: @@ -3240,7 +3240,7 @@ │ ├── pattern: │ │ @ SourceLineNode (location: (124,7)-(124,15)) │ │ └── flags: static_literal - │ └── operator_loc: (124,4)-(124,6) = "in" + │ └── keyword_loc: (124,4)-(124,6) = "in" ├── @ MatchPredicateNode (location: (125,0)-(125,19)) │ ├── flags: newline │ ├── value: @@ -3258,7 +3258,7 @@ │ ├── pattern: │ │ @ SourceEncodingNode (location: (125,7)-(125,19)) │ │ └── flags: static_literal - │ └── operator_loc: (125,4)-(125,6) = "in" + │ └── keyword_loc: (125,4)-(125,6) = "in" ├── @ MatchPredicateNode (location: (126,0)-(126,17)) │ ├── flags: newline │ ├── value: @@ -3289,7 +3289,7 @@ │ │ ├── flags: newline │ │ ├── name: :bar │ │ └── depth: 1 - │ └── operator_loc: (126,4)-(126,6) = "in" + │ └── keyword_loc: (126,4)-(126,6) = "in" ├── @ MatchPredicateNode (location: (127,0)-(127,11)) │ ├── flags: newline │ ├── value: @@ -3319,7 +3319,7 @@ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ - │ └── operator_loc: (127,4)-(127,6) = "in" + │ └── keyword_loc: (127,4)-(127,6) = "in" ├── @ CaseMatchNode (location: (129,0)-(129,25)) │ ├── flags: newline │ ├── predicate: @@ -3343,8 +3343,8 @@ │ │ │ ├── name: :bar │ │ │ └── depth: 0 │ │ ├── statements: ∅ - │ │ ├── in_loc: (129,10)-(129,12) = "in" - │ │ └── then_loc: (129,17)-(129,21) = "then" + │ │ ├── in_keyword_loc: (129,10)-(129,12) = "in" + │ │ └── then_keyword_loc: (129,17)-(129,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (129,0)-(129,4) = "case" │ └── end_keyword_loc: (129,22)-(129,25) = "end" @@ -3370,8 +3370,8 @@ │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 1 │ │ ├── statements: ∅ - │ │ ├── in_loc: (130,10)-(130,12) = "in" - │ │ └── then_loc: (130,15)-(130,19) = "then" + │ │ ├── in_keyword_loc: (130,10)-(130,12) = "in" + │ │ └── then_keyword_loc: (130,15)-(130,19) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (130,0)-(130,4) = "case" │ └── end_keyword_loc: (130,20)-(130,23) = "end" @@ -3397,8 +3397,8 @@ │ │ │ ├── flags: static_literal │ │ │ └── value: 1.0 │ │ ├── statements: ∅ - │ │ ├── in_loc: (131,10)-(131,12) = "in" - │ │ └── then_loc: (131,17)-(131,21) = "then" + │ │ ├── in_keyword_loc: (131,10)-(131,12) = "in" + │ │ └── then_keyword_loc: (131,17)-(131,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (131,0)-(131,4) = "case" │ └── end_keyword_loc: (131,22)-(131,25) = "end" @@ -3427,8 +3427,8 @@ │ │ │ ├── flags: static_literal, decimal │ │ │ └── value: 1 │ │ ├── statements: ∅ - │ │ ├── in_loc: (132,10)-(132,12) = "in" - │ │ └── then_loc: (132,16)-(132,20) = "then" + │ │ ├── in_keyword_loc: (132,10)-(132,12) = "in" + │ │ └── then_keyword_loc: (132,16)-(132,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (132,0)-(132,4) = "case" │ └── end_keyword_loc: (132,21)-(132,24) = "end" @@ -3455,8 +3455,8 @@ │ │ │ ├── numerator: 1 │ │ │ └── denominator: 1 │ │ ├── statements: ∅ - │ │ ├── in_loc: (133,10)-(133,12) = "in" - │ │ └── then_loc: (133,16)-(133,20) = "then" + │ │ ├── in_keyword_loc: (133,10)-(133,12) = "in" + │ │ └── then_keyword_loc: (133,16)-(133,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (133,0)-(133,4) = "case" │ └── end_keyword_loc: (133,21)-(133,24) = "end" @@ -3485,8 +3485,8 @@ │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (134,10)-(134,12) = "in" - │ │ └── then_loc: (134,18)-(134,22) = "then" + │ │ ├── in_keyword_loc: (134,10)-(134,12) = "in" + │ │ └── then_keyword_loc: (134,18)-(134,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (134,0)-(134,4) = "case" │ └── end_keyword_loc: (134,23)-(134,26) = "end" @@ -3515,8 +3515,8 @@ │ │ │ ├── closing_loc: (135,19)-(135,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (135,10)-(135,12) = "in" - │ │ └── then_loc: (135,21)-(135,25) = "then" + │ │ ├── in_keyword_loc: (135,10)-(135,12) = "in" + │ │ └── then_keyword_loc: (135,21)-(135,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (135,0)-(135,4) = "case" │ └── end_keyword_loc: (135,26)-(135,29) = "end" @@ -3545,8 +3545,8 @@ │ │ │ ├── closing_loc: (136,18)-(136,19) = "\"" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (136,10)-(136,12) = "in" - │ │ └── then_loc: (136,20)-(136,24) = "then" + │ │ ├── in_keyword_loc: (136,10)-(136,12) = "in" + │ │ └── then_keyword_loc: (136,20)-(136,24) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (136,0)-(136,4) = "case" │ └── end_keyword_loc: (136,25)-(136,28) = "end" @@ -3575,8 +3575,8 @@ │ │ │ ├── closing_loc: (137,17)-(137,18) = "/" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (137,10)-(137,12) = "in" - │ │ └── then_loc: (137,19)-(137,23) = "then" + │ │ ├── in_keyword_loc: (137,10)-(137,12) = "in" + │ │ └── then_keyword_loc: (137,19)-(137,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (137,0)-(137,4) = "case" │ └── end_keyword_loc: (137,24)-(137,27) = "end" @@ -3605,8 +3605,8 @@ │ │ │ ├── closing_loc: (138,17)-(138,18) = "`" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (138,10)-(138,12) = "in" - │ │ └── then_loc: (138,19)-(138,23) = "then" + │ │ ├── in_keyword_loc: (138,10)-(138,12) = "in" + │ │ └── then_keyword_loc: (138,19)-(138,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (138,0)-(138,4) = "case" │ └── end_keyword_loc: (138,24)-(138,27) = "end" @@ -3635,8 +3635,8 @@ │ │ │ ├── closing_loc: (139,19)-(139,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (139,10)-(139,12) = "in" - │ │ └── then_loc: (139,21)-(139,25) = "then" + │ │ ├── in_keyword_loc: (139,10)-(139,12) = "in" + │ │ └── then_keyword_loc: (139,21)-(139,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (139,0)-(139,4) = "case" │ └── end_keyword_loc: (139,26)-(139,29) = "end" @@ -3670,8 +3670,8 @@ │ │ │ ├── opening_loc: (140,13)-(140,16) = "%i[" │ │ │ └── closing_loc: (140,19)-(140,20) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (140,10)-(140,12) = "in" - │ │ └── then_loc: (140,21)-(140,25) = "then" + │ │ ├── in_keyword_loc: (140,10)-(140,12) = "in" + │ │ └── then_keyword_loc: (140,21)-(140,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (140,0)-(140,4) = "case" │ └── end_keyword_loc: (140,26)-(140,29) = "end" @@ -3705,8 +3705,8 @@ │ │ │ ├── opening_loc: (141,13)-(141,16) = "%I[" │ │ │ └── closing_loc: (141,19)-(141,20) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (141,10)-(141,12) = "in" - │ │ └── then_loc: (141,21)-(141,25) = "then" + │ │ ├── in_keyword_loc: (141,10)-(141,12) = "in" + │ │ └── then_keyword_loc: (141,21)-(141,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (141,0)-(141,4) = "case" │ └── end_keyword_loc: (141,26)-(141,29) = "end" @@ -3740,8 +3740,8 @@ │ │ │ ├── opening_loc: (142,13)-(142,16) = "%w[" │ │ │ └── closing_loc: (142,19)-(142,20) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (142,10)-(142,12) = "in" - │ │ └── then_loc: (142,21)-(142,25) = "then" + │ │ ├── in_keyword_loc: (142,10)-(142,12) = "in" + │ │ └── then_keyword_loc: (142,21)-(142,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (142,0)-(142,4) = "case" │ └── end_keyword_loc: (142,26)-(142,29) = "end" @@ -3775,8 +3775,8 @@ │ │ │ ├── opening_loc: (143,13)-(143,16) = "%W[" │ │ │ └── closing_loc: (143,19)-(143,20) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (143,10)-(143,12) = "in" - │ │ └── then_loc: (143,21)-(143,25) = "then" + │ │ ├── in_keyword_loc: (143,10)-(143,12) = "in" + │ │ └── then_keyword_loc: (143,21)-(143,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (143,0)-(143,4) = "case" │ └── end_keyword_loc: (143,26)-(143,29) = "end" @@ -3805,8 +3805,8 @@ │ │ │ ├── closing_loc: (144,19)-(144,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (144,10)-(144,12) = "in" - │ │ └── then_loc: (144,21)-(144,25) = "then" + │ │ ├── in_keyword_loc: (144,10)-(144,12) = "in" + │ │ └── then_keyword_loc: (144,21)-(144,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (144,0)-(144,4) = "case" │ └── end_keyword_loc: (144,26)-(144,29) = "end" @@ -3835,8 +3835,8 @@ │ │ │ ├── closing_loc: (145,19)-(145,20) = "]" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (145,10)-(145,12) = "in" - │ │ └── then_loc: (145,21)-(145,25) = "then" + │ │ ├── in_keyword_loc: (145,10)-(145,12) = "in" + │ │ └── then_keyword_loc: (145,21)-(145,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (145,0)-(145,4) = "case" │ └── end_keyword_loc: (145,26)-(145,29) = "end" @@ -3865,8 +3865,8 @@ │ │ │ ├── closing_loc: (146,17)-(146,18) = "\"" │ │ │ └── unescaped: "foo" │ │ ├── statements: ∅ - │ │ ├── in_loc: (146,10)-(146,12) = "in" - │ │ └── then_loc: (146,19)-(146,23) = "then" + │ │ ├── in_keyword_loc: (146,10)-(146,12) = "in" + │ │ └── then_keyword_loc: (146,19)-(146,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (146,0)-(146,4) = "case" │ └── end_keyword_loc: (146,24)-(146,27) = "end" @@ -3891,8 +3891,8 @@ │ │ │ @ NilNode (location: (147,13)-(147,16)) │ │ │ └── flags: static_literal │ │ ├── statements: ∅ - │ │ ├── in_loc: (147,10)-(147,12) = "in" - │ │ └── then_loc: (147,17)-(147,21) = "then" + │ │ ├── in_keyword_loc: (147,10)-(147,12) = "in" + │ │ └── then_keyword_loc: (147,17)-(147,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (147,0)-(147,4) = "case" │ └── end_keyword_loc: (147,22)-(147,25) = "end" @@ -3917,8 +3917,8 @@ │ │ │ @ SelfNode (location: (148,13)-(148,17)) │ │ │ └── flags: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (148,10)-(148,12) = "in" - │ │ └── then_loc: (148,18)-(148,22) = "then" + │ │ ├── in_keyword_loc: (148,10)-(148,12) = "in" + │ │ └── then_keyword_loc: (148,18)-(148,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (148,0)-(148,4) = "case" │ └── end_keyword_loc: (148,23)-(148,26) = "end" @@ -3943,8 +3943,8 @@ │ │ │ @ TrueNode (location: (149,13)-(149,17)) │ │ │ └── flags: static_literal │ │ ├── statements: ∅ - │ │ ├── in_loc: (149,10)-(149,12) = "in" - │ │ └── then_loc: (149,18)-(149,22) = "then" + │ │ ├── in_keyword_loc: (149,10)-(149,12) = "in" + │ │ └── then_keyword_loc: (149,18)-(149,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (149,0)-(149,4) = "case" │ └── end_keyword_loc: (149,23)-(149,26) = "end" @@ -3969,8 +3969,8 @@ │ │ │ @ FalseNode (location: (150,13)-(150,18)) │ │ │ └── flags: static_literal │ │ ├── statements: ∅ - │ │ ├── in_loc: (150,10)-(150,12) = "in" - │ │ └── then_loc: (150,19)-(150,23) = "then" + │ │ ├── in_keyword_loc: (150,10)-(150,12) = "in" + │ │ └── then_keyword_loc: (150,19)-(150,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (150,0)-(150,4) = "case" │ └── end_keyword_loc: (150,24)-(150,27) = "end" @@ -3996,8 +3996,8 @@ │ │ │ ├── flags: ∅ │ │ │ └── filepath: "patterns.txt" │ │ ├── statements: ∅ - │ │ ├── in_loc: (151,10)-(151,12) = "in" - │ │ └── then_loc: (151,22)-(151,26) = "then" + │ │ ├── in_keyword_loc: (151,10)-(151,12) = "in" + │ │ └── then_keyword_loc: (151,22)-(151,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (151,0)-(151,4) = "case" │ └── end_keyword_loc: (151,27)-(151,30) = "end" @@ -4022,8 +4022,8 @@ │ │ │ @ SourceLineNode (location: (152,13)-(152,21)) │ │ │ └── flags: static_literal │ │ ├── statements: ∅ - │ │ ├── in_loc: (152,10)-(152,12) = "in" - │ │ └── then_loc: (152,22)-(152,26) = "then" + │ │ ├── in_keyword_loc: (152,10)-(152,12) = "in" + │ │ └── then_keyword_loc: (152,22)-(152,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (152,0)-(152,4) = "case" │ └── end_keyword_loc: (152,27)-(152,30) = "end" @@ -4048,8 +4048,8 @@ │ │ │ @ SourceEncodingNode (location: (153,13)-(153,25)) │ │ │ └── flags: static_literal │ │ ├── statements: ∅ - │ │ ├── in_loc: (153,10)-(153,12) = "in" - │ │ └── then_loc: (153,26)-(153,30) = "then" + │ │ ├── in_keyword_loc: (153,10)-(153,12) = "in" + │ │ └── then_keyword_loc: (153,26)-(153,30) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (153,0)-(153,4) = "case" │ └── end_keyword_loc: (153,31)-(153,34) = "end" @@ -4087,8 +4087,8 @@ │ │ │ ├── name: :bar │ │ │ └── depth: 1 │ │ ├── statements: ∅ - │ │ ├── in_loc: (154,10)-(154,12) = "in" - │ │ └── then_loc: (154,24)-(154,28) = "then" + │ │ ├── in_keyword_loc: (154,10)-(154,12) = "in" + │ │ └── then_keyword_loc: (154,24)-(154,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (154,0)-(154,4) = "case" │ └── end_keyword_loc: (154,29)-(154,32) = "end" @@ -4130,8 +4130,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (156,10)-(156,12) = "in" - │ │ └── then_loc: (156,24)-(156,28) = "then" + │ │ ├── in_keyword_loc: (156,10)-(156,12) = "in" + │ │ └── then_keyword_loc: (156,24)-(156,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (156,0)-(156,4) = "case" │ └── end_keyword_loc: (156,29)-(156,32) = "end" @@ -4172,8 +4172,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (157,10)-(157,12) = "in" - │ │ └── then_loc: (157,22)-(157,26) = "then" + │ │ ├── in_keyword_loc: (157,10)-(157,12) = "in" + │ │ └── then_keyword_loc: (157,22)-(157,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (157,0)-(157,4) = "case" │ └── end_keyword_loc: (157,27)-(157,30) = "end" @@ -4214,8 +4214,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (158,10)-(158,12) = "in" - │ │ └── then_loc: (158,24)-(158,28) = "then" + │ │ ├── in_keyword_loc: (158,10)-(158,12) = "in" + │ │ └── then_keyword_loc: (158,24)-(158,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (158,0)-(158,4) = "case" │ └── end_keyword_loc: (158,29)-(158,32) = "end" @@ -4259,8 +4259,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (159,10)-(159,12) = "in" - │ │ └── then_loc: (159,23)-(159,27) = "then" + │ │ ├── in_keyword_loc: (159,10)-(159,12) = "in" + │ │ └── then_keyword_loc: (159,23)-(159,27) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (159,0)-(159,4) = "case" │ └── end_keyword_loc: (159,28)-(159,31) = "end" @@ -4302,8 +4302,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (160,10)-(160,12) = "in" - │ │ └── then_loc: (160,23)-(160,27) = "then" + │ │ ├── in_keyword_loc: (160,10)-(160,12) = "in" + │ │ └── then_keyword_loc: (160,23)-(160,27) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (160,0)-(160,4) = "case" │ └── end_keyword_loc: (160,28)-(160,31) = "end" @@ -4347,8 +4347,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (161,10)-(161,12) = "in" - │ │ └── then_loc: (161,25)-(161,29) = "then" + │ │ ├── in_keyword_loc: (161,10)-(161,12) = "in" + │ │ └── then_keyword_loc: (161,25)-(161,29) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (161,0)-(161,4) = "case" │ └── end_keyword_loc: (161,30)-(161,33) = "end" @@ -4392,8 +4392,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (162,10)-(162,12) = "in" - │ │ └── then_loc: (162,28)-(162,32) = "then" + │ │ ├── in_keyword_loc: (162,10)-(162,12) = "in" + │ │ └── then_keyword_loc: (162,28)-(162,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (162,0)-(162,4) = "case" │ └── end_keyword_loc: (162,33)-(162,36) = "end" @@ -4437,8 +4437,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (163,10)-(163,12) = "in" - │ │ └── then_loc: (163,27)-(163,31) = "then" + │ │ ├── in_keyword_loc: (163,10)-(163,12) = "in" + │ │ └── then_keyword_loc: (163,27)-(163,31) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (163,0)-(163,4) = "case" │ └── end_keyword_loc: (163,32)-(163,35) = "end" @@ -4482,8 +4482,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (164,10)-(164,12) = "in" - │ │ └── then_loc: (164,26)-(164,30) = "then" + │ │ ├── in_keyword_loc: (164,10)-(164,12) = "in" + │ │ └── then_keyword_loc: (164,26)-(164,30) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (164,0)-(164,4) = "case" │ └── end_keyword_loc: (164,31)-(164,34) = "end" @@ -4527,8 +4527,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (165,10)-(165,12) = "in" - │ │ └── then_loc: (165,26)-(165,30) = "then" + │ │ ├── in_keyword_loc: (165,10)-(165,12) = "in" + │ │ └── then_keyword_loc: (165,26)-(165,30) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (165,0)-(165,4) = "case" │ └── end_keyword_loc: (165,31)-(165,34) = "end" @@ -4572,8 +4572,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (166,10)-(166,12) = "in" - │ │ └── then_loc: (166,28)-(166,32) = "then" + │ │ ├── in_keyword_loc: (166,10)-(166,12) = "in" + │ │ └── then_keyword_loc: (166,28)-(166,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (166,0)-(166,4) = "case" │ └── end_keyword_loc: (166,33)-(166,36) = "end" @@ -4622,8 +4622,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (167,10)-(167,12) = "in" - │ │ └── then_loc: (167,28)-(167,32) = "then" + │ │ ├── in_keyword_loc: (167,10)-(167,12) = "in" + │ │ └── then_keyword_loc: (167,28)-(167,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (167,0)-(167,4) = "case" │ └── end_keyword_loc: (167,33)-(167,36) = "end" @@ -4672,8 +4672,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (168,10)-(168,12) = "in" - │ │ └── then_loc: (168,28)-(168,32) = "then" + │ │ ├── in_keyword_loc: (168,10)-(168,12) = "in" + │ │ └── then_keyword_loc: (168,28)-(168,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (168,0)-(168,4) = "case" │ └── end_keyword_loc: (168,33)-(168,36) = "end" @@ -4722,8 +4722,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (169,10)-(169,12) = "in" - │ │ └── then_loc: (169,28)-(169,32) = "then" + │ │ ├── in_keyword_loc: (169,10)-(169,12) = "in" + │ │ └── then_keyword_loc: (169,28)-(169,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (169,0)-(169,4) = "case" │ └── end_keyword_loc: (169,33)-(169,36) = "end" @@ -4772,8 +4772,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (170,10)-(170,12) = "in" - │ │ └── then_loc: (170,28)-(170,32) = "then" + │ │ ├── in_keyword_loc: (170,10)-(170,12) = "in" + │ │ └── then_keyword_loc: (170,28)-(170,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (170,0)-(170,4) = "case" │ └── end_keyword_loc: (170,33)-(170,36) = "end" @@ -4817,8 +4817,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (171,10)-(171,12) = "in" - │ │ └── then_loc: (171,28)-(171,32) = "then" + │ │ ├── in_keyword_loc: (171,10)-(171,12) = "in" + │ │ └── then_keyword_loc: (171,28)-(171,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (171,0)-(171,4) = "case" │ └── end_keyword_loc: (171,33)-(171,36) = "end" @@ -4862,8 +4862,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (172,10)-(172,12) = "in" - │ │ └── then_loc: (172,28)-(172,32) = "then" + │ │ ├── in_keyword_loc: (172,10)-(172,12) = "in" + │ │ └── then_keyword_loc: (172,28)-(172,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (172,0)-(172,4) = "case" │ └── end_keyword_loc: (172,33)-(172,36) = "end" @@ -4907,8 +4907,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (173,10)-(173,12) = "in" - │ │ └── then_loc: (173,26)-(173,30) = "then" + │ │ ├── in_keyword_loc: (173,10)-(173,12) = "in" + │ │ └── then_keyword_loc: (173,26)-(173,30) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (173,0)-(173,4) = "case" │ └── end_keyword_loc: (173,31)-(173,34) = "end" @@ -4948,8 +4948,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (174,10)-(174,12) = "in" - │ │ └── then_loc: (174,24)-(174,28) = "then" + │ │ ├── in_keyword_loc: (174,10)-(174,12) = "in" + │ │ └── then_keyword_loc: (174,24)-(174,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (174,0)-(174,4) = "case" │ └── end_keyword_loc: (174,29)-(174,32) = "end" @@ -4989,8 +4989,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (175,10)-(175,12) = "in" - │ │ └── then_loc: (175,25)-(175,29) = "then" + │ │ ├── in_keyword_loc: (175,10)-(175,12) = "in" + │ │ └── then_keyword_loc: (175,25)-(175,29) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (175,0)-(175,4) = "case" │ └── end_keyword_loc: (175,30)-(175,33) = "end" @@ -5030,8 +5030,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (176,10)-(176,12) = "in" - │ │ └── then_loc: (176,25)-(176,29) = "then" + │ │ ├── in_keyword_loc: (176,10)-(176,12) = "in" + │ │ └── then_keyword_loc: (176,25)-(176,29) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (176,0)-(176,4) = "case" │ └── end_keyword_loc: (176,30)-(176,33) = "end" @@ -5071,8 +5071,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (177,10)-(177,12) = "in" - │ │ └── then_loc: (177,26)-(177,30) = "then" + │ │ ├── in_keyword_loc: (177,10)-(177,12) = "in" + │ │ └── then_keyword_loc: (177,26)-(177,30) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (177,0)-(177,4) = "case" │ └── end_keyword_loc: (177,31)-(177,34) = "end" @@ -5113,8 +5113,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (178,10)-(178,12) = "in" - │ │ └── then_loc: (178,29)-(178,33) = "then" + │ │ ├── in_keyword_loc: (178,10)-(178,12) = "in" + │ │ └── then_keyword_loc: (178,29)-(178,33) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (178,0)-(178,4) = "case" │ └── end_keyword_loc: (178,34)-(178,37) = "end" @@ -5154,8 +5154,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (179,10)-(179,12) = "in" - │ │ └── then_loc: (179,29)-(179,33) = "then" + │ │ ├── in_keyword_loc: (179,10)-(179,12) = "in" + │ │ └── then_keyword_loc: (179,29)-(179,33) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (179,0)-(179,4) = "case" │ └── end_keyword_loc: (179,34)-(179,37) = "end" @@ -5195,8 +5195,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (180,10)-(180,12) = "in" - │ │ └── then_loc: (180,33)-(180,37) = "then" + │ │ ├── in_keyword_loc: (180,10)-(180,12) = "in" + │ │ └── then_keyword_loc: (180,33)-(180,37) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (180,0)-(180,4) = "case" │ └── end_keyword_loc: (180,38)-(180,41) = "end" @@ -5249,8 +5249,8 @@ │ │ │ ├── subsequent: ∅ │ │ │ └── end_keyword_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (181,10)-(181,12) = "in" - │ │ └── then_loc: (181,31)-(181,35) = "then" + │ │ ├── in_keyword_loc: (181,10)-(181,12) = "in" + │ │ └── then_keyword_loc: (181,31)-(181,35) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (181,0)-(181,4) = "case" │ └── end_keyword_loc: (181,36)-(181,39) = "end" @@ -5281,7 +5281,7 @@ │ │ │ ├── posts: (length: 0) │ │ │ ├── opening_loc: (183,8)-(183,9) = "[" │ │ │ └── closing_loc: (183,9)-(183,10) = "]" - │ │ └── operator_loc: (183,5)-(183,7) = "in" + │ │ └── keyword_loc: (183,5)-(183,7) = "in" │ ├── then_keyword_loc: ∅ │ ├── statements: ∅ │ ├── subsequent: ∅ @@ -5375,7 +5375,7 @@ │ │ ├── rest: ∅ │ │ ├── opening_loc: (190,8)-(190,9) = "[" │ │ └── closing_loc: (194,0)-(194,1) = "]" - │ └── operator_loc: (190,4)-(190,6) = "in" + │ └── keyword_loc: (190,4)-(190,6) = "in" ├── @ MatchPredicateNode (location: (196,0)-(196,17)) │ ├── flags: newline │ ├── value: @@ -5404,7 +5404,7 @@ │ │ │ ├── name: :baz │ │ │ └── depth: 0 │ │ └── operator_loc: (196,11)-(196,13) = "=>" - │ └── operator_loc: (196,4)-(196,6) = "in" + │ └── keyword_loc: (196,4)-(196,6) = "in" ├── @ MatchRequiredNode (location: (197,0)-(197,17)) │ ├── flags: newline │ ├── value: @@ -5613,7 +5613,7 @@ │ │ │ │ ├── name: :_1 │ │ │ │ └── depth: 0 │ │ │ └── operator_loc: (206,14)-(206,15) = "^" - │ │ └── operator_loc: (206,11)-(206,13) = "in" + │ │ └── keyword_loc: (206,11)-(206,13) = "in" │ ├── opening_loc: (206,7)-(206,8) = "{" │ └── closing_loc: (206,18)-(206,19) = "}" ├── @ MultiWriteNode (location: (208,0)-(211,5)) @@ -5673,8 +5673,8 @@ │ │ │ ├── opening_loc: (213,12)-(213,13) = "[" │ │ │ └── closing_loc: (213,19)-(213,20) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (213,9)-(213,11) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (213,9)-(213,11) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (213,0)-(213,4) = "case" │ └── end_keyword_loc: (213,22)-(213,25) = "end" @@ -5741,8 +5741,8 @@ │ │ │ ├── opening_loc: (214,12)-(214,13) = "[" │ │ │ └── closing_loc: (214,25)-(214,26) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (214,9)-(214,11) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (214,9)-(214,11) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (214,0)-(214,4) = "case" │ └── end_keyword_loc: (214,28)-(214,31) = "end" @@ -5808,7 +5808,7 @@ │ │ │ ├── posts: (length: 0) │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ - │ │ └── operator_loc: (217,2)-(217,4) = "in" + │ │ └── keyword_loc: (217,2)-(217,4) = "in" │ ├── right: │ │ @ CallNode (location: (217,12)-(217,13)) │ │ ├── flags: variable_call, ignore_visibility @@ -5847,7 +5847,7 @@ │ │ │ ├── posts: (length: 0) │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ - │ │ └── operator_loc: (218,2)-(218,4) = "in" + │ │ └── keyword_loc: (218,2)-(218,4) = "in" │ ├── right: │ │ @ CallNode (location: (218,11)-(218,12)) │ │ ├── flags: variable_call, ignore_visibility @@ -5892,7 +5892,7 @@ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── opening_loc: ∅ │ │ │ │ └── closing_loc: ∅ - │ │ │ └── operator_loc: (219,3)-(219,5) = "in" + │ │ │ └── keyword_loc: (219,3)-(219,5) = "in" │ │ ├── opening_loc: (219,0)-(219,1) = "(" │ │ └── closing_loc: (219,8)-(219,9) = ")" │ ├── right: @@ -5939,7 +5939,7 @@ │ │ │ │ ├── posts: (length: 0) │ │ │ │ ├── opening_loc: ∅ │ │ │ │ └── closing_loc: ∅ - │ │ │ └── operator_loc: (220,3)-(220,5) = "in" + │ │ │ └── keyword_loc: (220,3)-(220,5) = "in" │ │ ├── opening_loc: (220,0)-(220,1) = "(" │ │ └── closing_loc: (220,8)-(220,9) = ")" │ ├── right: diff --git a/snapshots/seattlerb/bug_case_when_regexp.txt b/snapshots/seattlerb/bug_case_when_regexp.txt index e24a170ad4..baaeac2466 100644 --- a/snapshots/seattlerb/bug_case_when_regexp.txt +++ b/snapshots/seattlerb/bug_case_when_regexp.txt @@ -17,7 +17,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,9)-(1,22)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,9)-(1,13) = "when" + │ ├── when_keyword_loc: (1,9)-(1,13) = "when" │ ├── conditions: (length: 1) │ │ └── @ RegularExpressionNode (location: (1,14)-(1,17)) │ │ ├── flags: static_literal, forced_us_ascii_encoding diff --git a/snapshots/seattlerb/bug_cond_pct.txt b/snapshots/seattlerb/bug_cond_pct.txt index 0b96c5c44e..28bd50bffc 100644 --- a/snapshots/seattlerb/bug_cond_pct.txt +++ b/snapshots/seattlerb/bug_cond_pct.txt @@ -11,7 +11,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,6)-(1,23)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,6)-(1,10) = "when" + │ ├── when_keyword_loc: (1,6)-(1,10) = "when" │ ├── conditions: (length: 1) │ │ └── @ RegularExpressionNode (location: (1,11)-(1,23)) │ │ ├── flags: static_literal, forced_us_ascii_encoding diff --git a/snapshots/seattlerb/case_in.txt b/snapshots/seattlerb/case_in.txt index 80a29db396..dce4f4a7e9 100644 --- a/snapshots/seattlerb/case_in.txt +++ b/snapshots/seattlerb/case_in.txt @@ -44,8 +44,8 @@ │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (3,0)-(3,3) = "end" @@ -80,8 +80,8 @@ │ │ │ ├── opening_loc: (6,3)-(6,6) = "%I[" │ │ │ └── closing_loc: (6,9)-(6,10) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (6,0)-(6,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (6,0)-(6,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (7,0)-(7,3) = "end" @@ -116,8 +116,8 @@ │ │ │ ├── opening_loc: (10,3)-(10,6) = "%W[" │ │ │ └── closing_loc: (10,9)-(10,10) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (10,0)-(10,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (10,0)-(10,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (11,0)-(11,3) = "end" @@ -152,8 +152,8 @@ │ │ │ ├── opening_loc: (14,3)-(14,6) = "%i[" │ │ │ └── closing_loc: (14,9)-(14,10) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (14,0)-(14,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (14,0)-(14,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (13,0)-(13,4) = "case" │ └── end_keyword_loc: (15,0)-(15,3) = "end" @@ -188,8 +188,8 @@ │ │ │ ├── opening_loc: (18,3)-(18,6) = "%w[" │ │ │ └── closing_loc: (18,9)-(18,10) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (18,0)-(18,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (18,0)-(18,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (17,0)-(17,4) = "case" │ └── end_keyword_loc: (19,0)-(19,3) = "end" @@ -220,8 +220,8 @@ │ │ │ ├── opening_loc: (22,3)-(22,4) = "(" │ │ │ └── closing_loc: (22,9)-(22,10) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (22,0)-(22,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (22,0)-(22,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (21,0)-(21,4) = "case" │ └── end_keyword_loc: (23,0)-(23,3) = "end" @@ -252,8 +252,8 @@ │ │ │ ├── opening_loc: (26,3)-(26,4) = "(" │ │ │ └── closing_loc: (26,8)-(26,9) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (26,0)-(26,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (26,0)-(26,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (25,0)-(25,4) = "case" │ └── end_keyword_loc: (27,0)-(27,3) = "end" @@ -284,8 +284,8 @@ │ │ │ ├── opening_loc: (30,3)-(30,4) = "(" │ │ │ └── closing_loc: (30,8)-(30,9) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (30,0)-(30,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (30,0)-(30,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (29,0)-(29,4) = "case" │ └── end_keyword_loc: (31,0)-(31,3) = "end" @@ -319,8 +319,8 @@ │ │ │ ├── opening_loc: (34,3)-(34,4) = "(" │ │ │ └── closing_loc: (34,9)-(34,10) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (34,0)-(34,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (34,0)-(34,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (33,0)-(33,4) = "case" │ └── end_keyword_loc: (35,0)-(35,3) = "end" @@ -346,8 +346,8 @@ │ │ │ ├── opening_loc: (38,3)-(38,4) = "(" │ │ │ └── closing_loc: (38,6)-(38,7) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (38,0)-(38,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (38,0)-(38,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (37,0)-(37,4) = "case" │ └── end_keyword_loc: (39,0)-(39,3) = "end" @@ -376,8 +376,8 @@ │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (42,0)-(42,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (42,0)-(42,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (41,0)-(41,4) = "case" │ └── end_keyword_loc: (43,0)-(43,3) = "end" @@ -401,8 +401,8 @@ │ │ │ ├── closing_loc: (46,10)-(46,11) = "/" │ │ │ └── unescaped: "regexp" │ │ ├── statements: ∅ - │ │ ├── in_loc: (46,0)-(46,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (46,0)-(46,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (45,0)-(45,4) = "case" │ └── end_keyword_loc: (47,0)-(47,3) = "end" @@ -448,8 +448,8 @@ │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (50,0)-(50,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (50,0)-(50,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (49,0)-(49,4) = "case" │ └── end_keyword_loc: (51,0)-(51,3) = "end" @@ -495,8 +495,8 @@ │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (54,0)-(54,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (54,0)-(54,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (53,0)-(53,4) = "case" │ └── end_keyword_loc: (55,0)-(55,3) = "end" @@ -525,8 +525,8 @@ │ │ │ ├── opening_loc: (58,9)-(58,10) = "(" │ │ │ └── closing_loc: (58,10)-(58,11) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (58,0)-(58,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (58,0)-(58,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (57,0)-(57,4) = "case" │ └── end_keyword_loc: (59,0)-(59,3) = "end" @@ -575,8 +575,8 @@ │ │ │ ├── opening_loc: (62,9)-(62,10) = "(" │ │ │ └── closing_loc: (62,23)-(62,24) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (62,0)-(62,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (62,0)-(62,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (61,0)-(61,4) = "case" │ └── end_keyword_loc: (63,0)-(63,3) = "end" @@ -625,8 +625,8 @@ │ │ │ ├── opening_loc: (66,9)-(66,10) = "[" │ │ │ └── closing_loc: (66,23)-(66,24) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (66,0)-(66,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (66,0)-(66,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (65,0)-(65,4) = "case" │ └── end_keyword_loc: (67,0)-(67,3) = "end" @@ -687,8 +687,8 @@ │ │ │ ├── opening_loc: (70,3)-(70,4) = "[" │ │ │ └── closing_loc: (70,21)-(70,22) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (70,0)-(70,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (70,0)-(70,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (69,0)-(69,4) = "case" │ └── end_keyword_loc: (71,0)-(71,3) = "end" @@ -752,8 +752,8 @@ │ │ │ ├── opening_loc: (74,3)-(74,4) = "[" │ │ │ └── closing_loc: (74,27)-(74,28) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (74,0)-(74,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (74,0)-(74,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (73,0)-(73,4) = "case" │ └── end_keyword_loc: (75,0)-(75,3) = "end" @@ -789,8 +789,8 @@ │ │ │ ├── opening_loc: (78,3)-(78,4) = "[" │ │ │ └── closing_loc: (78,11)-(78,12) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (78,0)-(78,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (78,0)-(78,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (77,0)-(77,4) = "case" │ └── end_keyword_loc: (79,0)-(79,3) = "end" @@ -856,8 +856,8 @@ │ │ │ ├── opening_loc: (82,3)-(82,4) = "[" │ │ │ └── closing_loc: (82,21)-(82,22) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (82,0)-(82,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (82,0)-(82,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (81,0)-(81,4) = "case" │ └── end_keyword_loc: (83,0)-(83,3) = "end" @@ -883,8 +883,8 @@ │ │ │ ├── opening_loc: (86,3)-(86,4) = "[" │ │ │ └── closing_loc: (86,4)-(86,5) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (86,0)-(86,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (86,0)-(86,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (85,0)-(85,4) = "case" │ └── end_keyword_loc: (87,0)-(87,3) = "end" @@ -927,8 +927,8 @@ │ │ │ ├── opening_loc: (90,3)-(90,4) = "[" │ │ │ └── closing_loc: (90,8)-(90,9) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (90,0)-(90,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (90,0)-(90,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (89,0)-(89,4) = "case" │ └── end_keyword_loc: (91,0)-(91,3) = "end" @@ -975,8 +975,8 @@ │ │ │ ├── opening_loc: (94,3)-(94,4) = "[" │ │ │ └── closing_loc: (94,18)-(94,19) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (94,0)-(94,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (94,0)-(94,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (93,0)-(93,4) = "case" │ └── end_keyword_loc: (95,0)-(95,3) = "end" @@ -1000,8 +1000,8 @@ │ │ │ ├── closing_loc: (98,11)-(98,12) = "`" │ │ │ └── unescaped: "echo hi" │ │ ├── statements: ∅ - │ │ ├── in_loc: (98,0)-(98,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (98,0)-(98,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (97,0)-(97,4) = "case" │ └── end_keyword_loc: (99,0)-(99,3) = "end" @@ -1033,8 +1033,8 @@ │ │ │ ├── opening_loc: ∅ │ │ │ └── closing_loc: ∅ │ │ ├── statements: ∅ - │ │ ├── in_loc: (102,0)-(102,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (102,0)-(102,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (101,0)-(101,4) = "case" │ └── end_keyword_loc: (103,0)-(103,3) = "end" @@ -1077,8 +1077,8 @@ │ │ │ ├── opening_loc: (106,3)-(106,4) = "{" │ │ │ └── closing_loc: (106,10)-(106,11) = "}" │ │ ├── statements: ∅ - │ │ ├── in_loc: (106,0)-(106,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (106,0)-(106,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (105,0)-(105,4) = "case" │ └── end_keyword_loc: (107,0)-(107,3) = "end" @@ -1103,8 +1103,8 @@ │ │ ├── opening_loc: (110,3)-(110,4) = "{" │ │ └── closing_loc: (110,4)-(110,5) = "}" │ ├── statements: ∅ - │ ├── in_loc: (110,0)-(110,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (110,0)-(110,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (109,0)-(109,4) = "case" └── end_keyword_loc: (111,0)-(111,3) = "end" diff --git a/snapshots/seattlerb/case_in_31.txt b/snapshots/seattlerb/case_in_31.txt index 4abddbcdce..06595b2faf 100644 --- a/snapshots/seattlerb/case_in_31.txt +++ b/snapshots/seattlerb/case_in_31.txt @@ -50,8 +50,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_37.txt b/snapshots/seattlerb/case_in_37.txt index 5ef6d916af..1b005c78e4 100644 --- a/snapshots/seattlerb/case_in_37.txt +++ b/snapshots/seattlerb/case_in_37.txt @@ -61,8 +61,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "c" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "c" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_42.txt b/snapshots/seattlerb/case_in_42.txt index 9c6d21c68e..a35f8bfec1 100644 --- a/snapshots/seattlerb/case_in_42.txt +++ b/snapshots/seattlerb/case_in_42.txt @@ -46,8 +46,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (2,15)-(2,18)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,10)-(2,14) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,10)-(2,14) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_42_2.txt b/snapshots/seattlerb/case_in_42_2.txt index e16df21fa2..d08bab5138 100644 --- a/snapshots/seattlerb/case_in_42_2.txt +++ b/snapshots/seattlerb/case_in_42_2.txt @@ -43,8 +43,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (2,17)-(2,20)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,12)-(2,16) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,12)-(2,16) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_47.txt b/snapshots/seattlerb/case_in_47.txt index ee11204f61..f4f0c5c5eb 100644 --- a/snapshots/seattlerb/case_in_47.txt +++ b/snapshots/seattlerb/case_in_47.txt @@ -52,8 +52,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_67.txt b/snapshots/seattlerb/case_in_67.txt index 103277a39d..3a4d01e3c4 100644 --- a/snapshots/seattlerb/case_in_67.txt +++ b/snapshots/seattlerb/case_in_67.txt @@ -32,8 +32,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (2,12)-(2,15)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,7)-(2,11) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,7)-(2,11) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_86.txt b/snapshots/seattlerb/case_in_86.txt index b163ae64e4..728f81236f 100644 --- a/snapshots/seattlerb/case_in_86.txt +++ b/snapshots/seattlerb/case_in_86.txt @@ -53,8 +53,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (2,22)-(2,25)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,17)-(2,21) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,17)-(2,21) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_86_2.txt b/snapshots/seattlerb/case_in_86_2.txt index bf6b2ff53d..41d31a80fa 100644 --- a/snapshots/seattlerb/case_in_86_2.txt +++ b/snapshots/seattlerb/case_in_86_2.txt @@ -53,8 +53,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (2,22)-(2,25)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,17)-(2,21) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,17)-(2,21) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_array_pat_const.txt b/snapshots/seattlerb/case_in_array_pat_const.txt index c0aae6a723..3969851285 100644 --- a/snapshots/seattlerb/case_in_array_pat_const.txt +++ b/snapshots/seattlerb/case_in_array_pat_const.txt @@ -43,8 +43,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_array_pat_const2.txt b/snapshots/seattlerb/case_in_array_pat_const2.txt index 7739dde628..f6bb17489c 100644 --- a/snapshots/seattlerb/case_in_array_pat_const2.txt +++ b/snapshots/seattlerb/case_in_array_pat_const2.txt @@ -49,8 +49,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "e" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "e" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_array_pat_paren_assign.txt b/snapshots/seattlerb/case_in_array_pat_paren_assign.txt index e34cac73c4..30be1ca346 100644 --- a/snapshots/seattlerb/case_in_array_pat_paren_assign.txt +++ b/snapshots/seattlerb/case_in_array_pat_paren_assign.txt @@ -51,8 +51,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_const.txt b/snapshots/seattlerb/case_in_const.txt index 49097d26df..544ef5b92f 100644 --- a/snapshots/seattlerb/case_in_const.txt +++ b/snapshots/seattlerb/case_in_const.txt @@ -28,8 +28,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "b" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "b" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_else.txt b/snapshots/seattlerb/case_in_else.txt index e0cdf5125c..3410488f83 100644 --- a/snapshots/seattlerb/case_in_else.txt +++ b/snapshots/seattlerb/case_in_else.txt @@ -28,8 +28,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "b" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "b" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: │ @ ElseNode (location: (4,0)-(6,3)) │ ├── flags: ∅ diff --git a/snapshots/seattlerb/case_in_find.txt b/snapshots/seattlerb/case_in_find.txt index c6337d7c85..7e7bc72393 100644 --- a/snapshots/seattlerb/case_in_find.txt +++ b/snapshots/seattlerb/case_in_find.txt @@ -49,8 +49,8 @@ │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ │ ├── statements: ∅ - │ ├── in_loc: (2,2)-(2,4) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,2)-(2,4) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_find_array.txt b/snapshots/seattlerb/case_in_find_array.txt index 986925904f..fd239fe93f 100644 --- a/snapshots/seattlerb/case_in_find_array.txt +++ b/snapshots/seattlerb/case_in_find_array.txt @@ -45,8 +45,8 @@ │ │ ├── opening_loc: (2,3)-(2,4) = "[" │ │ └── closing_loc: (2,15)-(2,16) = "]" │ ├── statements: ∅ - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat.txt b/snapshots/seattlerb/case_in_hash_pat.txt index e3f62d026e..c3dc16f867 100644 --- a/snapshots/seattlerb/case_in_hash_pat.txt +++ b/snapshots/seattlerb/case_in_hash_pat.txt @@ -69,8 +69,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "f" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "f" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,22)-(2,26) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,22)-(2,26) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat_assign.txt b/snapshots/seattlerb/case_in_hash_pat_assign.txt index 483c932680..ebd70af47f 100644 --- a/snapshots/seattlerb/case_in_hash_pat_assign.txt +++ b/snapshots/seattlerb/case_in_hash_pat_assign.txt @@ -93,8 +93,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "g" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "g" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,35)-(2,39) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,35)-(2,39) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt b/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt index b6e809326a..09e38a828c 100644 --- a/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt +++ b/snapshots/seattlerb/case_in_hash_pat_paren_assign.txt @@ -52,8 +52,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat_paren_true.txt b/snapshots/seattlerb/case_in_hash_pat_paren_true.txt index a544021030..bf3271f8d2 100644 --- a/snapshots/seattlerb/case_in_hash_pat_paren_true.txt +++ b/snapshots/seattlerb/case_in_hash_pat_paren_true.txt @@ -48,8 +48,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "c" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "c" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,11)-(2,15) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,11)-(2,15) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat_rest.txt b/snapshots/seattlerb/case_in_hash_pat_rest.txt index 71f7e126bc..8ab3caa780 100644 --- a/snapshots/seattlerb/case_in_hash_pat_rest.txt +++ b/snapshots/seattlerb/case_in_hash_pat_rest.txt @@ -58,8 +58,8 @@ │ │ ├── value_loc: (2,22)-(2,23) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,16)-(2,20) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,16)-(2,20) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt b/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt index 01b324e086..cdf4626ebd 100644 --- a/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt +++ b/snapshots/seattlerb/case_in_hash_pat_rest_solo.txt @@ -43,8 +43,8 @@ │ │ ├── value_loc: (2,16)-(2,17) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: (2,10)-(2,14) = "then" + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: (2,10)-(2,14) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (3,0)-(3,3) = "end" diff --git a/snapshots/seattlerb/case_in_if_unless_post_mod.txt b/snapshots/seattlerb/case_in_if_unless_post_mod.txt index 3da03ffbc3..be3f35570c 100644 --- a/snapshots/seattlerb/case_in_if_unless_post_mod.txt +++ b/snapshots/seattlerb/case_in_if_unless_post_mod.txt @@ -44,14 +44,14 @@ │ │ │ ├── value_loc: (3,3)-(3,4) = "C" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "C" - │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ └── then_keyword_loc: ∅ │ └── @ InNode (location: (4,0)-(5,4)) │ ├── flags: ∅ │ ├── pattern: │ │ @ UnlessNode (location: (4,3)-(4,17)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (4,5)-(4,11) = "unless" + │ │ ├── unless_keyword_loc: (4,5)-(4,11) = "unless" │ │ ├── predicate: │ │ │ @ FalseNode (location: (4,12)-(4,17)) │ │ │ └── flags: static_literal @@ -75,8 +75,8 @@ │ │ ├── value_loc: (5,3)-(5,4) = "E" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "E" - │ ├── in_loc: (4,0)-(4,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (4,0)-(4,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (6,0)-(6,3) = "end" diff --git a/snapshots/seattlerb/case_in_multiple.txt b/snapshots/seattlerb/case_in_multiple.txt index 173136fc6f..0d0706ad7f 100644 --- a/snapshots/seattlerb/case_in_multiple.txt +++ b/snapshots/seattlerb/case_in_multiple.txt @@ -37,8 +37,8 @@ │ │ │ ├── value_loc: (3,3)-(3,4) = "C" │ │ │ ├── closing_loc: ∅ │ │ │ └── unescaped: "C" - │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ └── then_keyword_loc: ∅ │ └── @ InNode (location: (4,0)-(5,4)) │ ├── flags: ∅ │ ├── pattern: @@ -61,8 +61,8 @@ │ │ ├── value_loc: (5,3)-(5,4) = "F" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "F" - │ ├── in_loc: (4,0)-(4,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (4,0)-(4,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (6,0)-(6,3) = "end" diff --git a/snapshots/seattlerb/case_in_or.txt b/snapshots/seattlerb/case_in_or.txt index 7bcf50293d..593f904e7d 100644 --- a/snapshots/seattlerb/case_in_or.txt +++ b/snapshots/seattlerb/case_in_or.txt @@ -39,8 +39,8 @@ │ │ ├── value_loc: (3,3)-(3,4) = "d" │ │ ├── closing_loc: ∅ │ │ └── unescaped: "d" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/in_expr_no_case.txt b/snapshots/seattlerb/in_expr_no_case.txt index 97493c73c1..2fa56ead9c 100644 --- a/snapshots/seattlerb/in_expr_no_case.txt +++ b/snapshots/seattlerb/in_expr_no_case.txt @@ -18,4 +18,4 @@ │ @ ConstantReadNode (location: (1,10)-(1,16)) │ ├── flags: ∅ │ └── name: :String - └── operator_loc: (1,7)-(1,9) = "in" + └── keyword_loc: (1,7)-(1,9) = "in" diff --git a/snapshots/seattlerb/parse_pattern_019.txt b/snapshots/seattlerb/parse_pattern_019.txt index 2c491f5b08..22f0e74dc6 100644 --- a/snapshots/seattlerb/parse_pattern_019.txt +++ b/snapshots/seattlerb/parse_pattern_019.txt @@ -32,8 +32,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (3,2)-(3,6)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_044.txt b/snapshots/seattlerb/parse_pattern_044.txt index 310928d523..73189dc7f2 100644 --- a/snapshots/seattlerb/parse_pattern_044.txt +++ b/snapshots/seattlerb/parse_pattern_044.txt @@ -40,8 +40,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (3,2)-(3,6)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_051.txt b/snapshots/seattlerb/parse_pattern_051.txt index 4bf6a890e7..d11d7a642c 100644 --- a/snapshots/seattlerb/parse_pattern_051.txt +++ b/snapshots/seattlerb/parse_pattern_051.txt @@ -48,8 +48,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (3,2)-(3,6)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_058.txt b/snapshots/seattlerb/parse_pattern_058.txt index 9ca66d88f6..cf0f8cd100 100644 --- a/snapshots/seattlerb/parse_pattern_058.txt +++ b/snapshots/seattlerb/parse_pattern_058.txt @@ -81,8 +81,8 @@ │ │ │ └── depth: 0 │ │ ├── opening_loc: (3,2)-(3,3) = "[" │ │ └── closing_loc: (3,10)-(3,11) = "]" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_058_2.txt b/snapshots/seattlerb/parse_pattern_058_2.txt index b72cefb096..2180cf9051 100644 --- a/snapshots/seattlerb/parse_pattern_058_2.txt +++ b/snapshots/seattlerb/parse_pattern_058_2.txt @@ -73,8 +73,8 @@ │ │ │ └── depth: 0 │ │ ├── opening_loc: (3,2)-(3,3) = "[" │ │ └── closing_loc: (3,4)-(3,5) = "]" - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_069.txt b/snapshots/seattlerb/parse_pattern_069.txt index fee569a90b..71fc3581fb 100644 --- a/snapshots/seattlerb/parse_pattern_069.txt +++ b/snapshots/seattlerb/parse_pattern_069.txt @@ -49,8 +49,8 @@ │ │ └── @ IntegerNode (location: (3,2)-(3,3)) │ │ ├── flags: newline, static_literal, decimal │ │ └── value: 1 - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_pattern_076.txt b/snapshots/seattlerb/parse_pattern_076.txt index 368bb94f36..ee8f20bef3 100644 --- a/snapshots/seattlerb/parse_pattern_076.txt +++ b/snapshots/seattlerb/parse_pattern_076.txt @@ -62,8 +62,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (3,2)-(3,6)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (2,0)-(2,2) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (4,0)-(4,3) = "end" diff --git a/snapshots/seattlerb/parse_until_not_canonical.txt b/snapshots/seattlerb/parse_until_not_canonical.txt index 792c34a71b..5c71ddac15 100644 --- a/snapshots/seattlerb/parse_until_not_canonical.txt +++ b/snapshots/seattlerb/parse_until_not_canonical.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ UntilNode (location: (1,0)-(3,3)) ├── flags: newline - ├── keyword_loc: (1,0)-(1,5) = "until" + ├── until_keyword_loc: (1,0)-(1,5) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,0)-(3,3) = "end" + ├── end_keyword_loc: (3,0)-(3,3) = "end" ├── predicate: │ @ CallNode (location: (1,6)-(1,18)) │ ├── flags: ∅ diff --git a/snapshots/seattlerb/parse_until_not_noncanonical.txt b/snapshots/seattlerb/parse_until_not_noncanonical.txt index 792c34a71b..5c71ddac15 100644 --- a/snapshots/seattlerb/parse_until_not_noncanonical.txt +++ b/snapshots/seattlerb/parse_until_not_noncanonical.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ UntilNode (location: (1,0)-(3,3)) ├── flags: newline - ├── keyword_loc: (1,0)-(1,5) = "until" + ├── until_keyword_loc: (1,0)-(1,5) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,0)-(3,3) = "end" + ├── end_keyword_loc: (3,0)-(3,3) = "end" ├── predicate: │ @ CallNode (location: (1,6)-(1,18)) │ ├── flags: ∅ diff --git a/snapshots/seattlerb/parse_while_not_canonical.txt b/snapshots/seattlerb/parse_while_not_canonical.txt index 9100273a4d..5054f95bd5 100644 --- a/snapshots/seattlerb/parse_while_not_canonical.txt +++ b/snapshots/seattlerb/parse_while_not_canonical.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ WhileNode (location: (1,0)-(3,3)) ├── flags: newline - ├── keyword_loc: (1,0)-(1,5) = "while" + ├── while_keyword_loc: (1,0)-(1,5) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,0)-(3,3) = "end" + ├── end_keyword_loc: (3,0)-(3,3) = "end" ├── predicate: │ @ CallNode (location: (1,6)-(1,18)) │ ├── flags: ∅ diff --git a/snapshots/seattlerb/parse_while_not_noncanonical.txt b/snapshots/seattlerb/parse_while_not_noncanonical.txt index 9100273a4d..5054f95bd5 100644 --- a/snapshots/seattlerb/parse_while_not_noncanonical.txt +++ b/snapshots/seattlerb/parse_while_not_noncanonical.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ WhileNode (location: (1,0)-(3,3)) ├── flags: newline - ├── keyword_loc: (1,0)-(1,5) = "while" + ├── while_keyword_loc: (1,0)-(1,5) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,0)-(3,3) = "end" + ├── end_keyword_loc: (3,0)-(3,3) = "end" ├── predicate: │ @ CallNode (location: (1,6)-(1,18)) │ ├── flags: ∅ diff --git a/snapshots/seattlerb/when_splat.txt b/snapshots/seattlerb/when_splat.txt index eab233c4fc..d7067ab406 100644 --- a/snapshots/seattlerb/when_splat.txt +++ b/snapshots/seattlerb/when_splat.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,8)-(1,20)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,8)-(1,12) = "when" + │ ├── when_keyword_loc: (1,8)-(1,12) = "when" │ ├── conditions: (length: 1) │ │ └── @ SplatNode (location: (1,13)-(1,15)) │ │ ├── flags: ∅ diff --git a/snapshots/unless.txt b/snapshots/unless.txt index 62b659193d..8d22cc8666 100644 --- a/snapshots/unless.txt +++ b/snapshots/unless.txt @@ -7,7 +7,7 @@ └── body: (length: 7) ├── @ UnlessNode (location: (1,0)-(1,19)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,6) = "unless" + │ ├── unless_keyword_loc: (1,0)-(1,6) = "unless" │ ├── predicate: │ │ @ TrueNode (location: (1,7)-(1,11)) │ │ └── flags: static_literal @@ -23,7 +23,7 @@ │ └── end_keyword_loc: (1,16)-(1,19) = "end" ├── @ UnlessNode (location: (3,0)-(4,12)) │ ├── flags: newline - │ ├── keyword_loc: (3,0)-(3,6) = "unless" + │ ├── unless_keyword_loc: (3,0)-(3,6) = "unless" │ ├── predicate: │ │ @ TrueNode (location: (3,7)-(3,11)) │ │ └── flags: static_literal @@ -50,7 +50,7 @@ │ └── end_keyword_loc: (4,9)-(4,12) = "end" ├── @ UnlessNode (location: (6,0)-(6,13)) │ ├── flags: newline - │ ├── keyword_loc: (6,2)-(6,8) = "unless" + │ ├── unless_keyword_loc: (6,2)-(6,8) = "unless" │ ├── predicate: │ │ @ TrueNode (location: (6,9)-(6,13)) │ │ └── flags: static_literal @@ -85,7 +85,7 @@ │ │ └── body: (length: 1) │ │ └── @ UnlessNode (location: (8,6)-(8,23)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (8,12)-(8,18) = "unless" + │ │ ├── unless_keyword_loc: (8,12)-(8,18) = "unless" │ │ ├── predicate: │ │ │ @ TrueNode (location: (8,19)-(8,23)) │ │ │ └── flags: static_literal @@ -123,7 +123,7 @@ │ │ └── body: (length: 1) │ │ └── @ UnlessNode (location: (10,6)-(10,22)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (10,11)-(10,17) = "unless" + │ │ ├── unless_keyword_loc: (10,11)-(10,17) = "unless" │ │ ├── predicate: │ │ │ @ TrueNode (location: (10,18)-(10,22)) │ │ │ └── flags: static_literal @@ -142,7 +142,7 @@ │ └── closing_loc: (10,23)-(10,24) = "}" ├── @ UnlessNode (location: (12,0)-(12,18)) │ ├── flags: newline - │ ├── keyword_loc: (12,7)-(12,13) = "unless" + │ ├── unless_keyword_loc: (12,7)-(12,13) = "unless" │ ├── predicate: │ │ @ TrueNode (location: (12,14)-(12,18)) │ │ └── flags: static_literal @@ -159,7 +159,7 @@ │ └── end_keyword_loc: ∅ └── @ UnlessNode (location: (14,0)-(14,22)) ├── flags: newline - ├── keyword_loc: (14,11)-(14,17) = "unless" + ├── unless_keyword_loc: (14,11)-(14,17) = "unless" ├── predicate: │ @ CallNode (location: (14,18)-(14,22)) │ ├── flags: ignore_visibility diff --git a/snapshots/unparser/corpus/literal/case.txt b/snapshots/unparser/corpus/literal/case.txt index f78a03a72e..29a47fa180 100644 --- a/snapshots/unparser/corpus/literal/case.txt +++ b/snapshots/unparser/corpus/literal/case.txt @@ -11,7 +11,7 @@ │ ├── conditions: (length: 2) │ │ ├── @ WhenNode (location: (2,0)-(3,5)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (2,0)-(2,4) = "when" + │ │ │ ├── when_keyword_loc: (2,0)-(2,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (2,5)-(2,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -42,7 +42,7 @@ │ │ │ └── block: ∅ │ │ └── @ WhenNode (location: (4,0)-(5,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (4,0)-(4,4) = "when" + │ │ ├── when_keyword_loc: (4,0)-(4,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (4,5)-(4,8)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -91,7 +91,7 @@ │ ├── conditions: (length: 2) │ │ ├── @ WhenNode (location: (8,0)-(8,8)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (8,0)-(8,4) = "when" + │ │ │ ├── when_keyword_loc: (8,0)-(8,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (8,5)-(8,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -108,7 +108,7 @@ │ │ │ └── statements: ∅ │ │ └── @ WhenNode (location: (9,0)-(10,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (9,0)-(9,4) = "when" + │ │ ├── when_keyword_loc: (9,0)-(9,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (9,5)-(9,8)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -157,7 +157,7 @@ │ ├── conditions: (length: 2) │ │ ├── @ WhenNode (location: (13,0)-(14,5)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (13,0)-(13,4) = "when" + │ │ │ ├── when_keyword_loc: (13,0)-(13,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (13,5)-(13,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -188,7 +188,7 @@ │ │ │ └── block: ∅ │ │ └── @ WhenNode (location: (15,0)-(16,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (15,0)-(15,4) = "when" + │ │ ├── when_keyword_loc: (15,0)-(15,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (15,5)-(15,8)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -237,7 +237,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (19,0)-(20,8)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (19,0)-(19,4) = "when" + │ │ ├── when_keyword_loc: (19,0)-(19,4) = "when" │ │ ├── conditions: (length: 2) │ │ │ ├── @ CallNode (location: (19,5)-(19,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -292,7 +292,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (23,0)-(24,8)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (23,0)-(23,4) = "when" + │ │ ├── when_keyword_loc: (23,0)-(23,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SplatNode (location: (23,5)-(23,9)) │ │ │ ├── flags: ∅ @@ -340,7 +340,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (27,0)-(28,5)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (27,0)-(27,4) = "when" + │ │ ├── when_keyword_loc: (27,0)-(27,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ CallNode (location: (27,5)-(27,8)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -403,7 +403,7 @@ │ ├── conditions: (length: 1) │ │ └── @ WhenNode (location: (33,0)-(33,15)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (33,0)-(33,4) = "when" + │ │ ├── when_keyword_loc: (33,0)-(33,4) = "when" │ │ ├── conditions: (length: 1) │ │ │ └── @ SplatNode (location: (33,5)-(33,15)) │ │ │ ├── flags: ∅ @@ -467,7 +467,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (36,0)-(36,15)) │ ├── flags: ∅ - │ ├── keyword_loc: (36,0)-(36,4) = "when" + │ ├── when_keyword_loc: (36,0)-(36,4) = "when" │ ├── conditions: (length: 1) │ │ └── @ SplatNode (location: (36,5)-(36,15)) │ │ ├── flags: ∅ diff --git a/snapshots/unparser/corpus/literal/if.txt b/snapshots/unparser/corpus/literal/if.txt index a1603c48e4..891bbdfa11 100644 --- a/snapshots/unparser/corpus/literal/if.txt +++ b/snapshots/unparser/corpus/literal/if.txt @@ -80,7 +80,7 @@ │ └── end_keyword_loc: (11,0)-(11,3) = "end" ├── @ UnlessNode (location: (12,0)-(14,3)) │ ├── flags: newline - │ ├── keyword_loc: (12,0)-(12,6) = "unless" + │ ├── unless_keyword_loc: (12,0)-(12,6) = "unless" │ ├── predicate: │ │ @ IntegerNode (location: (12,7)-(12,8)) │ │ ├── flags: static_literal, decimal @@ -96,7 +96,7 @@ │ └── end_keyword_loc: (14,0)-(14,3) = "end" ├── @ UnlessNode (location: (15,0)-(17,3)) │ ├── flags: newline - │ ├── keyword_loc: (15,0)-(15,6) = "unless" + │ ├── unless_keyword_loc: (15,0)-(15,6) = "unless" │ ├── predicate: │ │ @ IntegerNode (location: (15,7)-(15,8)) │ │ ├── flags: static_literal, decimal @@ -191,7 +191,7 @@ │ │ └── body: (length: 1) │ │ └── @ UnlessNode (location: (26,2)-(26,22)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (26,12)-(26,18) = "unless" + │ │ ├── unless_keyword_loc: (26,12)-(26,18) = "unless" │ │ ├── predicate: │ │ │ @ LocalVariableReadNode (location: (26,19)-(26,22)) │ │ │ ├── flags: ∅ @@ -226,7 +226,7 @@ │ └── name: :B ├── @ UnlessNode (location: (28,0)-(30,3)) │ ├── flags: newline - │ ├── keyword_loc: (28,0)-(28,6) = "unless" + │ ├── unless_keyword_loc: (28,0)-(28,6) = "unless" │ ├── predicate: │ │ @ CallNode (location: (28,7)-(28,10)) │ │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/unparser/corpus/literal/pattern.txt b/snapshots/unparser/corpus/literal/pattern.txt index 57506dbd0d..d467ea3d9d 100644 --- a/snapshots/unparser/corpus/literal/pattern.txt +++ b/snapshots/unparser/corpus/literal/pattern.txt @@ -57,8 +57,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (3,2)-(3,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ │ └── then_loc: (2,18)-(2,22) = "then" + │ │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ │ └── then_keyword_loc: (2,18)-(2,22) = "then" │ │ ├── @ InNode (location: (4,0)-(5,3)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -93,8 +93,8 @@ │ │ │ │ ├── closing_loc: ∅ │ │ │ │ ├── equal_loc: ∅ │ │ │ │ └── block: ∅ - │ │ │ ├── in_loc: (4,0)-(4,2) = "in" - │ │ │ └── then_loc: (4,12)-(4,16) = "then" + │ │ │ ├── in_keyword_loc: (4,0)-(4,2) = "in" + │ │ │ └── then_keyword_loc: (4,12)-(4,16) = "then" │ │ ├── @ InNode (location: (6,0)-(7,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -132,8 +132,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (7,2)-(7,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (6,0)-(6,2) = "in" - │ │ │ └── then_loc: (6,9)-(6,13) = "then" + │ │ │ ├── in_keyword_loc: (6,0)-(6,2) = "in" + │ │ │ └── then_keyword_loc: (6,9)-(6,13) = "then" │ │ ├── @ InNode (location: (8,0)-(9,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -158,8 +158,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (9,2)-(9,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (8,0)-(8,2) = "in" - │ │ │ └── then_loc: (8,9)-(8,13) = "then" + │ │ │ ├── in_keyword_loc: (8,0)-(8,2) = "in" + │ │ │ └── then_keyword_loc: (8,9)-(8,13) = "then" │ │ ├── @ InNode (location: (10,0)-(11,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -189,8 +189,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (11,2)-(11,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (10,0)-(10,2) = "in" - │ │ │ └── then_loc: (10,14)-(10,18) = "then" + │ │ │ ├── in_keyword_loc: (10,0)-(10,2) = "in" + │ │ │ └── then_keyword_loc: (10,14)-(10,18) = "then" │ │ ├── @ InNode (location: (12,0)-(13,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -220,8 +220,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (13,2)-(13,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (12,0)-(12,2) = "in" - │ │ │ └── then_loc: (12,13)-(12,17) = "then" + │ │ │ ├── in_keyword_loc: (12,0)-(12,2) = "in" + │ │ │ └── then_keyword_loc: (12,13)-(12,17) = "then" │ │ ├── @ InNode (location: (14,0)-(15,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -266,8 +266,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (15,2)-(15,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (14,0)-(14,2) = "in" - │ │ │ └── then_loc: (14,17)-(14,21) = "then" + │ │ │ ├── in_keyword_loc: (14,0)-(14,2) = "in" + │ │ │ └── then_keyword_loc: (14,17)-(14,21) = "then" │ │ ├── @ InNode (location: (16,0)-(17,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -284,8 +284,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (17,2)-(17,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (16,0)-(16,2) = "in" - │ │ │ └── then_loc: (16,6)-(16,10) = "then" + │ │ │ ├── in_keyword_loc: (16,0)-(16,2) = "in" + │ │ │ └── then_keyword_loc: (16,6)-(16,10) = "then" │ │ ├── @ InNode (location: (18,0)-(19,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -306,8 +306,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (19,2)-(19,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (18,0)-(18,2) = "in" - │ │ │ └── then_loc: (18,11)-(18,15) = "then" + │ │ │ ├── in_keyword_loc: (18,0)-(18,2) = "in" + │ │ │ └── then_keyword_loc: (18,11)-(18,15) = "then" │ │ ├── @ InNode (location: (20,0)-(21,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -338,8 +338,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (21,2)-(21,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (20,0)-(20,2) = "in" - │ │ │ └── then_loc: (20,12)-(20,16) = "then" + │ │ │ ├── in_keyword_loc: (20,0)-(20,2) = "in" + │ │ │ └── then_keyword_loc: (20,12)-(20,16) = "then" │ │ ├── @ InNode (location: (22,0)-(23,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -360,8 +360,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (23,2)-(23,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (22,0)-(22,2) = "in" - │ │ │ └── then_loc: (22,9)-(22,13) = "then" + │ │ │ ├── in_keyword_loc: (22,0)-(22,2) = "in" + │ │ │ └── then_keyword_loc: (22,9)-(22,13) = "then" │ │ ├── @ InNode (location: (24,0)-(25,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -383,8 +383,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (25,2)-(25,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (24,0)-(24,2) = "in" - │ │ │ └── then_loc: (24,10)-(24,14) = "then" + │ │ │ ├── in_keyword_loc: (24,0)-(24,2) = "in" + │ │ │ └── then_keyword_loc: (24,10)-(24,14) = "then" │ │ ├── @ InNode (location: (26,0)-(27,6)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -402,8 +402,8 @@ │ │ │ │ └── body: (length: 1) │ │ │ │ └── @ TrueNode (location: (27,2)-(27,6)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (26,0)-(26,2) = "in" - │ │ │ └── then_loc: (26,6)-(26,10) = "then" + │ │ │ ├── in_keyword_loc: (26,0)-(26,2) = "in" + │ │ │ └── then_keyword_loc: (26,6)-(26,10) = "then" │ │ ├── @ InNode (location: (28,0)-(28,4)) │ │ │ ├── flags: ∅ │ │ │ ├── pattern: @@ -411,8 +411,8 @@ │ │ │ │ ├── flags: static_literal, decimal │ │ │ │ └── value: 1 │ │ │ ├── statements: ∅ - │ │ │ ├── in_loc: (28,0)-(28,2) = "in" - │ │ │ └── then_loc: ∅ + │ │ │ ├── in_keyword_loc: (28,0)-(28,2) = "in" + │ │ │ └── then_keyword_loc: ∅ │ │ └── @ InNode (location: (29,0)-(30,6)) │ │ ├── flags: ∅ │ │ ├── pattern: @@ -425,8 +425,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (30,2)-(30,6)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (29,0)-(29,2) = "in" - │ │ └── then_loc: (29,5)-(29,9) = "then" + │ │ ├── in_keyword_loc: (29,0)-(29,2) = "in" + │ │ └── then_keyword_loc: (29,5)-(29,9) = "then" │ ├── else_clause: │ │ @ ElseNode (location: (31,0)-(33,3)) │ │ ├── flags: ∅ @@ -487,8 +487,8 @@ │ │ │ ├── opening_loc: (35,4)-(35,5) = "[" │ │ │ └── closing_loc: (35,16)-(35,17) = "]" │ │ ├── statements: ∅ - │ │ ├── in_loc: (35,0)-(35,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (35,0)-(35,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (34,0)-(34,4) = "case" │ └── end_keyword_loc: (36,0)-(36,3) = "end" @@ -514,8 +514,8 @@ │ │ │ ├── flags: ∅ │ │ │ └── name: :A │ │ ├── statements: ∅ - │ │ ├── in_loc: (38,0)-(38,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (38,0)-(38,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: │ │ @ ElseNode (location: (39,0)-(40,3)) │ │ ├── flags: ∅ @@ -543,4 +543,4 @@ │ ├── posts: (length: 0) │ ├── opening_loc: (41,5)-(41,6) = "[" │ └── closing_loc: (41,7)-(41,8) = "]" - └── operator_loc: (41,2)-(41,4) = "in" + └── keyword_loc: (41,2)-(41,4) = "in" diff --git a/snapshots/unparser/corpus/literal/send.txt b/snapshots/unparser/corpus/literal/send.txt index 82dc2cc7f7..1a63cba8a7 100644 --- a/snapshots/unparser/corpus/literal/send.txt +++ b/snapshots/unparser/corpus/literal/send.txt @@ -212,7 +212,7 @@ │ │ ├── conditions: (length: 1) │ │ │ └── @ WhenNode (location: (18,0)-(18,8)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (18,0)-(18,4) = "when" + │ │ │ ├── when_keyword_loc: (18,0)-(18,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (18,5)-(18,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -258,7 +258,7 @@ │ │ ├── conditions: (length: 1) │ │ │ └── @ WhenNode (location: (21,0)-(21,8)) │ │ │ ├── flags: ∅ - │ │ │ ├── keyword_loc: (21,0)-(21,4) = "when" + │ │ │ ├── when_keyword_loc: (21,0)-(21,4) = "when" │ │ │ ├── conditions: (length: 1) │ │ │ │ └── @ CallNode (location: (21,5)-(21,8)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -362,9 +362,9 @@ │ ├── receiver: │ │ @ UntilNode (location: (29,0)-(30,3)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (29,0)-(29,5) = "until" + │ │ ├── until_keyword_loc: (29,0)-(29,5) = "until" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (30,0)-(30,3) = "end" + │ │ ├── end_keyword_loc: (30,0)-(30,3) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (29,6)-(29,9)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -391,9 +391,9 @@ │ ├── receiver: │ │ @ WhileNode (location: (31,0)-(32,3)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (31,0)-(31,5) = "while" + │ │ ├── while_keyword_loc: (31,0)-(31,5) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (32,0)-(32,3) = "end" + │ │ ├── end_keyword_loc: (32,0)-(32,3) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (31,6)-(31,9)) │ │ │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/unparser/corpus/literal/since/30.txt b/snapshots/unparser/corpus/literal/since/30.txt index 0102b2c97b..49c85ceb4c 100644 --- a/snapshots/unparser/corpus/literal/since/30.txt +++ b/snapshots/unparser/corpus/literal/since/30.txt @@ -71,7 +71,7 @@ │ │ │ └── expression: ∅ │ │ ├── opening_loc: (3,5)-(3,6) = "[" │ │ └── closing_loc: (3,14)-(3,15) = "]" - │ └── operator_loc: (3,2)-(3,4) = "in" + │ └── keyword_loc: (3,2)-(3,4) = "in" └── @ MatchPredicateNode (location: (4,0)-(4,17)) ├── flags: newline ├── value: @@ -103,4 +103,4 @@ │ │ └── depth: 0 │ ├── opening_loc: (4,5)-(4,6) = "[" │ └── closing_loc: (4,16)-(4,17) = "]" - └── operator_loc: (4,2)-(4,4) = "in" + └── keyword_loc: (4,2)-(4,4) = "in" diff --git a/snapshots/unparser/corpus/literal/while.txt b/snapshots/unparser/corpus/literal/while.txt index f11ba958a6..ffc9af4ee0 100644 --- a/snapshots/unparser/corpus/literal/while.txt +++ b/snapshots/unparser/corpus/literal/while.txt @@ -56,9 +56,9 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (3,4)-(5,7)) │ │ │ ├── flags: newline - │ │ │ ├── keyword_loc: (3,4)-(3,9) = "while" + │ │ │ ├── while_keyword_loc: (3,4)-(3,9) = "while" │ │ │ ├── do_keyword_loc: ∅ - │ │ │ ├── closing_loc: (5,4)-(5,7) = "end" + │ │ │ ├── end_keyword_loc: (5,4)-(5,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (3,10)-(3,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -102,9 +102,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (10,2)-(10,28)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (10,12)-(10,17) = "while" + │ │ ├── while_keyword_loc: (10,12)-(10,17) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ CallNode (location: (10,18)-(10,28)) │ │ │ ├── flags: ∅ @@ -178,9 +178,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (14,2)-(14,21)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (14,12)-(14,17) = "while" + │ │ ├── while_keyword_loc: (14,12)-(14,17) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ LocalVariableReadNode (location: (14,18)-(14,21)) │ │ │ ├── flags: ∅ @@ -224,9 +224,9 @@ │ │ └── body: (length: 1) │ │ └── @ UntilNode (location: (18,2)-(18,21)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (18,12)-(18,17) = "until" + │ │ ├── until_keyword_loc: (18,12)-(18,17) = "until" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ LocalVariableReadNode (location: (18,18)-(18,21)) │ │ │ ├── flags: ∅ @@ -270,9 +270,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (22,2)-(24,5)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (22,2)-(22,7) = "while" + │ │ ├── while_keyword_loc: (22,2)-(22,7) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (24,2)-(24,5) = "end" + │ │ ├── end_keyword_loc: (24,2)-(24,5) = "end" │ │ ├── predicate: │ │ │ @ CallNode (location: (22,8)-(22,11)) │ │ │ ├── flags: variable_call, ignore_visibility @@ -360,9 +360,9 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (29,4)-(31,7)) │ │ │ ├── flags: newline - │ │ │ ├── keyword_loc: (29,4)-(29,9) = "while" + │ │ │ ├── while_keyword_loc: (29,4)-(29,9) = "while" │ │ │ ├── do_keyword_loc: ∅ - │ │ │ ├── closing_loc: (31,4)-(31,7) = "end" + │ │ │ ├── end_keyword_loc: (31,4)-(31,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (29,10)-(29,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -452,9 +452,9 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (37,4)-(39,7)) │ │ │ ├── flags: newline - │ │ │ ├── keyword_loc: (37,4)-(37,9) = "while" + │ │ │ ├── while_keyword_loc: (37,4)-(37,9) = "while" │ │ │ ├── do_keyword_loc: ∅ - │ │ │ ├── closing_loc: (39,4)-(39,7) = "end" + │ │ │ ├── end_keyword_loc: (39,4)-(39,7) = "end" │ │ │ ├── predicate: │ │ │ │ @ LocalVariableReadNode (location: (37,10)-(37,13)) │ │ │ │ ├── flags: ∅ @@ -500,9 +500,9 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ WhileNode (location: (42,5)-(44,13)) │ │ │ ├── flags: newline, begin_modifier - │ │ │ ├── keyword_loc: (44,4)-(44,9) = "while" + │ │ │ ├── while_keyword_loc: (44,4)-(44,9) = "while" │ │ │ ├── do_keyword_loc: ∅ - │ │ │ ├── closing_loc: ∅ + │ │ │ ├── end_keyword_loc: ∅ │ │ │ ├── predicate: │ │ │ │ @ CallNode (location: (44,10)-(44,13)) │ │ │ │ ├── flags: variable_call, ignore_visibility @@ -546,9 +546,9 @@ │ └── operator_loc: (42,2)-(42,3) = "=" ├── @ WhileNode (location: (45,0)-(47,13)) │ ├── flags: newline, begin_modifier - │ ├── keyword_loc: (47,4)-(47,9) = "while" + │ ├── while_keyword_loc: (47,4)-(47,9) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (47,10)-(47,13)) │ │ ├── flags: variable_call, ignore_visibility @@ -589,9 +589,9 @@ │ └── end_keyword_loc: (47,0)-(47,3) = "end" ├── @ UntilNode (location: (48,0)-(51,13)) │ ├── flags: newline, begin_modifier - │ ├── keyword_loc: (51,4)-(51,9) = "until" + │ ├── until_keyword_loc: (51,4)-(51,9) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (51,10)-(51,13)) │ │ ├── flags: variable_call, ignore_visibility @@ -643,9 +643,9 @@ │ └── end_keyword_loc: (51,0)-(51,3) = "end" ├── @ WhileNode (location: (52,0)-(55,13)) │ ├── flags: newline, begin_modifier - │ ├── keyword_loc: (55,4)-(55,9) = "while" + │ ├── while_keyword_loc: (55,4)-(55,9) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (55,10)-(55,13)) │ │ ├── flags: variable_call, ignore_visibility @@ -697,18 +697,18 @@ │ └── end_keyword_loc: (55,0)-(55,3) = "end" ├── @ WhileNode (location: (56,0)-(57,3)) │ ├── flags: newline - │ ├── keyword_loc: (56,0)-(56,5) = "while" + │ ├── while_keyword_loc: (56,0)-(56,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (57,0)-(57,3) = "end" + │ ├── end_keyword_loc: (57,0)-(57,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (56,6)-(56,11)) │ │ └── flags: static_literal │ └── statements: ∅ ├── @ WhileNode (location: (58,0)-(60,3)) │ ├── flags: newline - │ ├── keyword_loc: (58,0)-(58,5) = "while" + │ ├── while_keyword_loc: (58,0)-(58,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (60,0)-(60,3) = "end" + │ ├── end_keyword_loc: (60,0)-(60,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (58,6)-(58,11)) │ │ └── flags: static_literal @@ -721,9 +721,9 @@ │ └── value: 3 ├── @ WhileNode (location: (61,0)-(64,3)) │ ├── flags: newline - │ ├── keyword_loc: (61,0)-(61,5) = "while" + │ ├── while_keyword_loc: (61,0)-(61,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (64,0)-(64,3) = "end" + │ ├── end_keyword_loc: (64,0)-(64,3) = "end" │ ├── predicate: │ │ @ ParenthesesNode (location: (61,6)-(62,2)) │ │ ├── flags: ∅ @@ -763,18 +763,18 @@ │ └── unescaped: "body" ├── @ UntilNode (location: (65,0)-(66,3)) │ ├── flags: newline - │ ├── keyword_loc: (65,0)-(65,5) = "until" + │ ├── until_keyword_loc: (65,0)-(65,5) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (66,0)-(66,3) = "end" + │ ├── end_keyword_loc: (66,0)-(66,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (65,6)-(65,11)) │ │ └── flags: static_literal │ └── statements: ∅ ├── @ UntilNode (location: (67,0)-(69,3)) │ ├── flags: newline - │ ├── keyword_loc: (67,0)-(67,5) = "until" + │ ├── until_keyword_loc: (67,0)-(67,5) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (69,0)-(69,3) = "end" + │ ├── end_keyword_loc: (69,0)-(69,3) = "end" │ ├── predicate: │ │ @ FalseNode (location: (67,6)-(67,11)) │ │ └── flags: static_literal @@ -787,9 +787,9 @@ │ └── value: 3 └── @ UntilNode (location: (70,0)-(73,3)) ├── flags: newline - ├── keyword_loc: (70,0)-(70,5) = "until" + ├── until_keyword_loc: (70,0)-(70,5) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: (73,0)-(73,3) = "end" + ├── end_keyword_loc: (73,0)-(73,3) = "end" ├── predicate: │ @ ParenthesesNode (location: (70,6)-(71,2)) │ ├── flags: ∅ diff --git a/snapshots/unparser/corpus/semantic/while.txt b/snapshots/unparser/corpus/semantic/while.txt index 36f7b07c8d..328e68961b 100644 --- a/snapshots/unparser/corpus/semantic/while.txt +++ b/snapshots/unparser/corpus/semantic/while.txt @@ -7,9 +7,9 @@ └── body: (length: 7) ├── @ UntilNode (location: (1,0)-(1,13)) │ ├── flags: newline - │ ├── keyword_loc: (1,2)-(1,7) = "until" + │ ├── until_keyword_loc: (1,2)-(1,7) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (1,8)-(1,13)) │ │ ├── flags: ignore_visibility @@ -46,9 +46,9 @@ │ └── block: ∅ ├── @ UntilNode (location: (3,0)-(5,3)) │ ├── flags: newline - │ ├── keyword_loc: (3,0)-(3,5) = "until" + │ ├── until_keyword_loc: (3,0)-(3,5) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (5,0)-(5,3) = "end" + │ ├── end_keyword_loc: (5,0)-(5,3) = "end" │ ├── predicate: │ │ @ CallNode (location: (3,6)-(3,11)) │ │ ├── flags: ignore_visibility @@ -85,9 +85,9 @@ │ └── block: ∅ ├── @ WhileNode (location: (7,0)-(7,19)) │ ├── flags: newline - │ ├── keyword_loc: (7,10)-(7,15) = "while" + │ ├── while_keyword_loc: (7,10)-(7,15) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ LocalVariableReadNode (location: (7,16)-(7,19)) │ │ ├── flags: ∅ @@ -117,9 +117,9 @@ │ └── operator_loc: (7,4)-(7,5) = "=" ├── @ UntilNode (location: (9,0)-(9,18)) │ ├── flags: newline - │ ├── keyword_loc: (9,2)-(9,7) = "until" + │ ├── until_keyword_loc: (9,2)-(9,7) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ AndNode (location: (9,8)-(9,18)) │ │ ├── flags: ∅ @@ -172,9 +172,9 @@ │ └── block: ∅ ├── @ WhileNode (location: (11,0)-(13,3)) │ ├── flags: newline - │ ├── keyword_loc: (11,0)-(11,5) = "while" + │ ├── while_keyword_loc: (11,0)-(11,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (13,0)-(13,3) = "end" + │ ├── end_keyword_loc: (13,0)-(13,3) = "end" │ ├── predicate: │ │ @ LocalVariableWriteNode (location: (11,6)-(11,11)) │ │ ├── flags: ∅ @@ -204,9 +204,9 @@ │ └── depth: 0 ├── @ UntilNode (location: (15,0)-(18,3)) │ ├── flags: newline - │ ├── keyword_loc: (15,2)-(15,7) = "until" + │ ├── until_keyword_loc: (15,2)-(15,7) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (15,8)-(18,3)) │ │ ├── flags: ignore_visibility @@ -289,9 +289,9 @@ │ │ └── operator_loc: (21,6)-(21,7) = "=" │ └── @ WhileNode (location: (22,2)-(24,5)) │ ├── flags: newline - │ ├── keyword_loc: (22,2)-(22,7) = "while" + │ ├── while_keyword_loc: (22,2)-(22,7) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (24,2)-(24,5) = "end" + │ ├── end_keyword_loc: (24,2)-(24,5) = "end" │ ├── predicate: │ │ @ LocalVariableReadNode (location: (22,8)-(22,11)) │ │ ├── flags: ∅ diff --git a/snapshots/until.txt b/snapshots/until.txt index 55b3beafa8..9f955eb6fc 100644 --- a/snapshots/until.txt +++ b/snapshots/until.txt @@ -7,9 +7,9 @@ └── body: (length: 7) ├── @ UntilNode (location: (1,0)-(1,18)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,5) = "until" + │ ├── until_keyword_loc: (1,0)-(1,5) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (1,15)-(1,18) = "end" + │ ├── end_keyword_loc: (1,15)-(1,18) = "end" │ ├── predicate: │ │ @ TrueNode (location: (1,6)-(1,10)) │ │ └── flags: static_literal @@ -22,9 +22,9 @@ │ └── value: 1 ├── @ UntilNode (location: (3,0)-(3,12)) │ ├── flags: newline - │ ├── keyword_loc: (3,2)-(3,7) = "until" + │ ├── until_keyword_loc: (3,2)-(3,7) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ TrueNode (location: (3,8)-(3,12)) │ │ └── flags: static_literal @@ -56,9 +56,9 @@ │ │ └── body: (length: 1) │ │ └── @ UntilNode (location: (5,6)-(5,22)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (5,12)-(5,17) = "until" + │ │ ├── until_keyword_loc: (5,12)-(5,17) = "until" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ TrueNode (location: (5,18)-(5,22)) │ │ │ └── flags: static_literal @@ -93,9 +93,9 @@ │ │ └── body: (length: 1) │ │ └── @ UntilNode (location: (7,6)-(7,21)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (7,11)-(7,16) = "until" + │ │ ├── until_keyword_loc: (7,11)-(7,16) = "until" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ TrueNode (location: (7,17)-(7,21)) │ │ │ └── flags: static_literal @@ -111,9 +111,9 @@ │ └── closing_loc: (7,22)-(7,23) = "}" ├── @ UntilNode (location: (9,0)-(9,17)) │ ├── flags: newline - │ ├── keyword_loc: (9,7)-(9,12) = "until" + │ ├── until_keyword_loc: (9,7)-(9,12) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ TrueNode (location: (9,13)-(9,17)) │ │ └── flags: static_literal @@ -127,9 +127,9 @@ │ └── arguments: ∅ ├── @ UntilNode (location: (11,0)-(11,21)) │ ├── flags: newline - │ ├── keyword_loc: (11,11)-(11,16) = "until" + │ ├── until_keyword_loc: (11,11)-(11,16) = "until" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (11,17)-(11,21)) │ │ ├── flags: ignore_visibility @@ -174,9 +174,9 @@ │ └── block: ∅ └── @ WhileNode (location: (13,0)-(13,20)) ├── flags: newline - ├── keyword_loc: (13,4)-(13,9) = "while" + ├── while_keyword_loc: (13,4)-(13,9) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ MatchPredicateNode (location: (13,10)-(13,20)) │ ├── flags: ∅ @@ -197,7 +197,7 @@ │ │ ├── flags: ∅ │ │ ├── name: :baz │ │ └── depth: 0 - │ └── operator_loc: (13,14)-(13,16) = "in" + │ └── keyword_loc: (13,14)-(13,16) = "in" └── statements: @ StatementsNode (location: (13,0)-(13,3)) ├── flags: ∅ diff --git a/snapshots/while.txt b/snapshots/while.txt index 67d45e4d66..ae4ae0a99e 100644 --- a/snapshots/while.txt +++ b/snapshots/while.txt @@ -7,9 +7,9 @@ └── body: (length: 12) ├── @ WhileNode (location: (1,0)-(1,18)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,5) = "while" + │ ├── while_keyword_loc: (1,0)-(1,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (1,15)-(1,18) = "end" + │ ├── end_keyword_loc: (1,15)-(1,18) = "end" │ ├── predicate: │ │ @ TrueNode (location: (1,6)-(1,10)) │ │ └── flags: static_literal @@ -22,9 +22,9 @@ │ └── value: 1 ├── @ WhileNode (location: (3,0)-(3,12)) │ ├── flags: newline - │ ├── keyword_loc: (3,2)-(3,7) = "while" + │ ├── while_keyword_loc: (3,2)-(3,7) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ TrueNode (location: (3,8)-(3,12)) │ │ └── flags: static_literal @@ -56,9 +56,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (5,6)-(5,22)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (5,12)-(5,17) = "while" + │ │ ├── while_keyword_loc: (5,12)-(5,17) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ TrueNode (location: (5,18)-(5,22)) │ │ │ └── flags: static_literal @@ -93,9 +93,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (7,6)-(7,21)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (7,11)-(7,16) = "while" + │ │ ├── while_keyword_loc: (7,11)-(7,16) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: ∅ + │ │ ├── end_keyword_loc: ∅ │ │ ├── predicate: │ │ │ @ TrueNode (location: (7,17)-(7,21)) │ │ │ └── flags: static_literal @@ -111,9 +111,9 @@ │ └── closing_loc: (7,22)-(7,23) = "}" ├── @ WhileNode (location: (9,0)-(9,17)) │ ├── flags: newline - │ ├── keyword_loc: (9,7)-(9,12) = "while" + │ ├── while_keyword_loc: (9,7)-(9,12) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ TrueNode (location: (9,13)-(9,17)) │ │ └── flags: static_literal @@ -127,9 +127,9 @@ │ └── arguments: ∅ ├── @ WhileNode (location: (11,0)-(11,21)) │ ├── flags: newline - │ ├── keyword_loc: (11,11)-(11,16) = "while" + │ ├── while_keyword_loc: (11,11)-(11,16) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: ∅ + │ ├── end_keyword_loc: ∅ │ ├── predicate: │ │ @ CallNode (location: (11,17)-(11,21)) │ │ ├── flags: ignore_visibility @@ -193,9 +193,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (13,6)-(13,56)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (13,6)-(13,11) = "while" + │ │ ├── while_keyword_loc: (13,6)-(13,11) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (13,53)-(13,56) = "end" + │ │ ├── end_keyword_loc: (13,53)-(13,56) = "end" │ │ ├── predicate: │ │ │ @ DefNode (location: (13,12)-(13,44)) │ │ │ ├── flags: ∅ @@ -277,9 +277,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (15,6)-(15,53)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (15,6)-(15,11) = "while" + │ │ ├── while_keyword_loc: (15,6)-(15,11) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (15,50)-(15,53) = "end" + │ │ ├── end_keyword_loc: (15,50)-(15,53) = "end" │ │ ├── predicate: │ │ │ @ ClassNode (location: (15,12)-(15,41)) │ │ │ ├── flags: ∅ @@ -353,9 +353,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (17,6)-(17,54)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (17,6)-(17,11) = "while" + │ │ ├── while_keyword_loc: (17,6)-(17,11) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (17,51)-(17,54) = "end" + │ │ ├── end_keyword_loc: (17,51)-(17,54) = "end" │ │ ├── predicate: │ │ │ @ SingletonClassNode (location: (17,12)-(17,42)) │ │ │ ├── flags: ∅ @@ -419,9 +419,9 @@ │ │ └── body: (length: 1) │ │ └── @ WhileNode (location: (19,6)-(19,58)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (19,6)-(19,11) = "while" + │ │ ├── while_keyword_loc: (19,6)-(19,11) = "while" │ │ ├── do_keyword_loc: ∅ - │ │ ├── closing_loc: (19,55)-(19,58) = "end" + │ │ ├── end_keyword_loc: (19,55)-(19,58) = "end" │ │ ├── predicate: │ │ │ @ SingletonClassNode (location: (19,12)-(19,46)) │ │ │ ├── flags: ∅ @@ -473,9 +473,9 @@ │ └── closing_loc: (19,59)-(19,60) = "}" ├── @ WhileNode (location: (21,0)-(21,31)) │ ├── flags: newline - │ ├── keyword_loc: (21,0)-(21,5) = "while" + │ ├── while_keyword_loc: (21,0)-(21,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (21,28)-(21,31) = "end" + │ ├── end_keyword_loc: (21,28)-(21,31) = "end" │ ├── predicate: │ │ @ DefNode (location: (21,6)-(21,26)) │ │ ├── flags: ∅ @@ -515,9 +515,9 @@ │ └── statements: ∅ └── @ WhileNode (location: (23,0)-(23,20)) ├── flags: newline - ├── keyword_loc: (23,4)-(23,9) = "while" + ├── while_keyword_loc: (23,4)-(23,9) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ MatchPredicateNode (location: (23,10)-(23,20)) │ ├── flags: ∅ @@ -538,7 +538,7 @@ │ │ ├── flags: ∅ │ │ ├── name: :baz │ │ └── depth: 0 - │ └── operator_loc: (23,14)-(23,16) = "in" + │ └── keyword_loc: (23,14)-(23,16) = "in" └── statements: @ StatementsNode (location: (23,0)-(23,3)) ├── flags: ∅ diff --git a/snapshots/whitequark/bug_while_not_parens_do.txt b/snapshots/whitequark/bug_while_not_parens_do.txt index c52f62db3f..5afc0e6fc0 100644 --- a/snapshots/whitequark/bug_while_not_parens_do.txt +++ b/snapshots/whitequark/bug_while_not_parens_do.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ WhileNode (location: (1,0)-(1,23)) ├── flags: newline - ├── keyword_loc: (1,0)-(1,5) = "while" + ├── while_keyword_loc: (1,0)-(1,5) = "while" ├── do_keyword_loc: (1,17)-(1,19) = "do" - ├── closing_loc: (1,20)-(1,23) = "end" + ├── end_keyword_loc: (1,20)-(1,23) = "end" ├── predicate: │ @ CallNode (location: (1,6)-(1,16)) │ ├── flags: ∅ diff --git a/snapshots/whitequark/case_cond.txt b/snapshots/whitequark/case_cond.txt index ed6f62071c..e0f8a22755 100644 --- a/snapshots/whitequark/case_cond.txt +++ b/snapshots/whitequark/case_cond.txt @@ -11,7 +11,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,6)-(1,21)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,6)-(1,10) = "when" + │ ├── when_keyword_loc: (1,6)-(1,10) = "when" │ ├── conditions: (length: 1) │ │ └── @ CallNode (location: (1,11)-(1,14)) │ │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/case_cond_else.txt b/snapshots/whitequark/case_cond_else.txt index 5826ddc83b..3cd52ad786 100644 --- a/snapshots/whitequark/case_cond_else.txt +++ b/snapshots/whitequark/case_cond_else.txt @@ -11,7 +11,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,6)-(1,21)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,6)-(1,10) = "when" + │ ├── when_keyword_loc: (1,6)-(1,10) = "when" │ ├── conditions: (length: 1) │ │ └── @ CallNode (location: (1,11)-(1,14)) │ │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/case_expr.txt b/snapshots/whitequark/case_expr.txt index cff0639836..f34c1828d6 100644 --- a/snapshots/whitequark/case_expr.txt +++ b/snapshots/whitequark/case_expr.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,10)-(1,25)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,10)-(1,14) = "when" + │ ├── when_keyword_loc: (1,10)-(1,14) = "when" │ ├── conditions: (length: 1) │ │ └── @ StringNode (location: (1,15)-(1,20)) │ │ ├── flags: static_literal, frozen diff --git a/snapshots/whitequark/case_expr_else.txt b/snapshots/whitequark/case_expr_else.txt index 6d8c71e54c..773cd87e53 100644 --- a/snapshots/whitequark/case_expr_else.txt +++ b/snapshots/whitequark/case_expr_else.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,10)-(1,25)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,10)-(1,14) = "when" + │ ├── when_keyword_loc: (1,10)-(1,14) = "when" │ ├── conditions: (length: 1) │ │ └── @ StringNode (location: (1,15)-(1,20)) │ │ ├── flags: static_literal, frozen diff --git a/snapshots/whitequark/find_pattern.txt b/snapshots/whitequark/find_pattern.txt index 2c4d67507c..010e6eed5e 100644 --- a/snapshots/whitequark/find_pattern.txt +++ b/snapshots/whitequark/find_pattern.txt @@ -48,8 +48,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (1,27)-(1,31)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,22)-(1,26) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,22)-(1,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,33)-(1,36) = "end" @@ -99,8 +99,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (3,33)-(3,37)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,28)-(3,32) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,28)-(3,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,39)-(3,42) = "end" @@ -150,8 +150,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (5,34)-(5,38)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: (5,29)-(5,33) = "then" + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: (5,29)-(5,33) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,40)-(5,43) = "end" @@ -215,8 +215,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (7,35)-(7,39)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (7,10)-(7,12) = "in" - │ └── then_loc: (7,30)-(7,34) = "then" + │ ├── in_keyword_loc: (7,10)-(7,12) = "in" + │ └── then_keyword_loc: (7,30)-(7,34) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (7,0)-(7,4) = "case" └── end_keyword_loc: (7,41)-(7,44) = "end" diff --git a/snapshots/whitequark/method_definition_in_while_cond.txt b/snapshots/whitequark/method_definition_in_while_cond.txt index e1ef297eed..9a7c578d2f 100644 --- a/snapshots/whitequark/method_definition_in_while_cond.txt +++ b/snapshots/whitequark/method_definition_in_while_cond.txt @@ -7,9 +7,9 @@ └── body: (length: 4) ├── @ WhileNode (location: (1,0)-(1,45)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,5) = "while" + │ ├── while_keyword_loc: (1,0)-(1,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (1,42)-(1,45) = "end" + │ ├── end_keyword_loc: (1,42)-(1,45) = "end" │ ├── predicate: │ │ @ DefNode (location: (1,6)-(1,33)) │ │ ├── flags: ∅ @@ -68,9 +68,9 @@ │ └── keyword_loc: (1,35)-(1,40) = "break" ├── @ WhileNode (location: (3,0)-(3,42)) │ ├── flags: newline - │ ├── keyword_loc: (3,0)-(3,5) = "while" + │ ├── while_keyword_loc: (3,0)-(3,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (3,39)-(3,42) = "end" + │ ├── end_keyword_loc: (3,39)-(3,42) = "end" │ ├── predicate: │ │ @ DefNode (location: (3,6)-(3,30)) │ │ ├── flags: ∅ @@ -117,9 +117,9 @@ │ └── keyword_loc: (3,32)-(3,37) = "break" ├── @ WhileNode (location: (5,0)-(5,50)) │ ├── flags: newline - │ ├── keyword_loc: (5,0)-(5,5) = "while" + │ ├── while_keyword_loc: (5,0)-(5,5) = "while" │ ├── do_keyword_loc: ∅ - │ ├── closing_loc: (5,47)-(5,50) = "end" + │ ├── end_keyword_loc: (5,47)-(5,50) = "end" │ ├── predicate: │ │ @ DefNode (location: (5,6)-(5,38)) │ │ ├── flags: ∅ @@ -180,9 +180,9 @@ │ └── keyword_loc: (5,40)-(5,45) = "break" └── @ WhileNode (location: (7,0)-(7,47)) ├── flags: newline - ├── keyword_loc: (7,0)-(7,5) = "while" + ├── while_keyword_loc: (7,0)-(7,5) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: (7,44)-(7,47) = "end" + ├── end_keyword_loc: (7,44)-(7,47) = "end" ├── predicate: │ @ DefNode (location: (7,6)-(7,35)) │ ├── flags: ∅ diff --git a/snapshots/whitequark/multiple_pattern_matches.txt b/snapshots/whitequark/multiple_pattern_matches.txt index 24cf259e08..ba8983e39c 100644 --- a/snapshots/whitequark/multiple_pattern_matches.txt +++ b/snapshots/whitequark/multiple_pattern_matches.txt @@ -151,7 +151,7 @@ │ │ ├── rest: ∅ │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ - │ └── operator_loc: (4,7)-(4,9) = "in" + │ └── keyword_loc: (4,7)-(4,9) = "in" └── @ MatchPredicateNode (location: (5,0)-(5,12)) ├── flags: newline ├── value: @@ -200,4 +200,4 @@ │ ├── rest: ∅ │ ├── opening_loc: ∅ │ └── closing_loc: ∅ - └── operator_loc: (5,7)-(5,9) = "in" + └── keyword_loc: (5,7)-(5,9) = "in" diff --git a/snapshots/whitequark/newline_in_hash_argument.txt b/snapshots/whitequark/newline_in_hash_argument.txt index 6aa9a7415d..c156d7bb1c 100644 --- a/snapshots/whitequark/newline_in_hash_argument.txt +++ b/snapshots/whitequark/newline_in_hash_argument.txt @@ -57,8 +57,8 @@ │ │ │ │ │ └── value: 0 │ │ │ │ └── @ TrueNode (location: (4,0)-(4,4)) │ │ │ │ └── flags: newline, static_literal - │ │ │ ├── in_loc: (2,0)-(2,2) = "in" - │ │ │ └── then_loc: ∅ + │ │ │ ├── in_keyword_loc: (2,0)-(2,2) = "in" + │ │ │ └── then_keyword_loc: ∅ │ │ └── @ InNode (location: (5,0)-(7,4)) │ │ ├── flags: ∅ │ │ ├── pattern: @@ -96,8 +96,8 @@ │ │ │ │ └── value: 0 │ │ │ └── @ TrueNode (location: (7,0)-(7,4)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,0)-(5,2) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (5,0)-(5,2) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (8,0)-(8,3) = "end" diff --git a/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt b/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt index a4879bfa51..318cbb4cff 100644 --- a/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt +++ b/snapshots/whitequark/pattern_matching__FILE__LINE_literals.txt @@ -57,8 +57,8 @@ │ │ ├── opening_loc: (2,13)-(2,14) = "[" │ │ └── closing_loc: (2,46)-(2,47) = "]" │ ├── statements: ∅ - │ ├── in_loc: (2,10)-(2,12) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (2,10)-(2,12) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,8)-(1,12) = "case" └── end_keyword_loc: (3,8)-(3,11) = "end" diff --git a/snapshots/whitequark/pattern_matching_blank_else.txt b/snapshots/whitequark/pattern_matching_blank_else.txt index af14e7b5a6..34aafc69c0 100644 --- a/snapshots/whitequark/pattern_matching_blank_else.txt +++ b/snapshots/whitequark/pattern_matching_blank_else.txt @@ -25,8 +25,8 @@ │ │ └── @ IntegerNode (location: (1,14)-(1,15)) │ │ ├── flags: newline, static_literal, decimal │ │ └── value: 3 - │ ├── in_loc: (1,8)-(1,10) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (1,8)-(1,10) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: │ @ ElseNode (location: (1,17)-(1,26)) │ ├── flags: ∅ diff --git a/snapshots/whitequark/pattern_matching_const_pattern.txt b/snapshots/whitequark/pattern_matching_const_pattern.txt index 065eefa681..2179217fb9 100644 --- a/snapshots/whitequark/pattern_matching_const_pattern.txt +++ b/snapshots/whitequark/pattern_matching_const_pattern.txt @@ -40,8 +40,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (1,22)-(1,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,17)-(1,21) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,17)-(1,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,28)-(1,31) = "end" @@ -86,8 +86,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (3,26)-(3,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,21)-(3,25) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,21)-(3,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,32)-(3,35) = "end" @@ -143,8 +143,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (5,24)-(5,28)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: (5,19)-(5,23) = "then" + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: (5,19)-(5,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,30)-(5,33) = "end" @@ -189,8 +189,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (7,26)-(7,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (7,10)-(7,12) = "in" - │ │ └── then_loc: (7,21)-(7,25) = "then" + │ │ ├── in_keyword_loc: (7,10)-(7,12) = "in" + │ │ └── then_keyword_loc: (7,21)-(7,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (7,0)-(7,4) = "case" │ └── end_keyword_loc: (7,32)-(7,35) = "end" @@ -229,8 +229,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (9,22)-(9,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (9,10)-(9,12) = "in" - │ │ └── then_loc: (9,17)-(9,21) = "then" + │ │ ├── in_keyword_loc: (9,10)-(9,12) = "in" + │ │ └── then_keyword_loc: (9,17)-(9,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (9,28)-(9,31) = "end" @@ -286,8 +286,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (11,24)-(11,28)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (11,10)-(11,12) = "in" - │ └── then_loc: (11,19)-(11,23) = "then" + │ ├── in_keyword_loc: (11,10)-(11,12) = "in" + │ └── then_keyword_loc: (11,19)-(11,23) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (11,0)-(11,4) = "case" └── end_keyword_loc: (11,30)-(11,33) = "end" diff --git a/snapshots/whitequark/pattern_matching_constants.txt b/snapshots/whitequark/pattern_matching_constants.txt index 78d86f86fa..5ed719c426 100644 --- a/snapshots/whitequark/pattern_matching_constants.txt +++ b/snapshots/whitequark/pattern_matching_constants.txt @@ -35,8 +35,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (1,22)-(1,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,17)-(1,21) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,17)-(1,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,28)-(1,31) = "end" @@ -67,8 +67,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (3,20)-(3,24)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,15)-(3,19) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,15)-(3,19) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,26)-(3,29) = "end" @@ -105,8 +105,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (5,23)-(5,27)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (5,10)-(5,12) = "in" - │ └── then_loc: (5,18)-(5,22) = "then" + │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ └── then_keyword_loc: (5,18)-(5,22) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (5,0)-(5,4) = "case" └── end_keyword_loc: (5,29)-(5,32) = "end" diff --git a/snapshots/whitequark/pattern_matching_else.txt b/snapshots/whitequark/pattern_matching_else.txt index 010f002716..98ec86b5e1 100644 --- a/snapshots/whitequark/pattern_matching_else.txt +++ b/snapshots/whitequark/pattern_matching_else.txt @@ -25,8 +25,8 @@ │ │ └── @ IntegerNode (location: (1,14)-(1,15)) │ │ ├── flags: newline, static_literal, decimal │ │ └── value: 3 - │ ├── in_loc: (1,8)-(1,10) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (1,8)-(1,10) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: │ @ ElseNode (location: (1,17)-(1,29)) │ ├── flags: ∅ diff --git a/snapshots/whitequark/pattern_matching_explicit_array_match.txt b/snapshots/whitequark/pattern_matching_explicit_array_match.txt index 17aeed9bb3..37c725a370 100644 --- a/snapshots/whitequark/pattern_matching_explicit_array_match.txt +++ b/snapshots/whitequark/pattern_matching_explicit_array_match.txt @@ -45,8 +45,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (1,25)-(1,29)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,20)-(1,24) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,20)-(1,24) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,31)-(1,34) = "end" @@ -94,8 +94,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (3,26)-(3,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,21)-(3,25) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,21)-(3,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,32)-(3,35) = "end" @@ -143,8 +143,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (5,28)-(5,32)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: (5,23)-(5,27) = "then" + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: (5,23)-(5,27) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,34)-(5,37) = "end" @@ -196,8 +196,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (7,29)-(7,33)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (7,10)-(7,12) = "in" - │ │ └── then_loc: (7,24)-(7,28) = "then" + │ │ ├── in_keyword_loc: (7,10)-(7,12) = "in" + │ │ └── then_keyword_loc: (7,24)-(7,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (7,0)-(7,4) = "case" │ └── end_keyword_loc: (7,35)-(7,38) = "end" @@ -245,8 +245,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (9,28)-(9,32)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (9,10)-(9,12) = "in" - │ │ └── then_loc: (9,23)-(9,27) = "then" + │ │ ├── in_keyword_loc: (9,10)-(9,12) = "in" + │ │ └── then_keyword_loc: (9,23)-(9,27) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (9,34)-(9,37) = "end" @@ -298,8 +298,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (11,29)-(11,33)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (11,10)-(11,12) = "in" - │ │ └── then_loc: (11,24)-(11,28) = "then" + │ │ ├── in_keyword_loc: (11,10)-(11,12) = "in" + │ │ └── then_keyword_loc: (11,24)-(11,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (11,0)-(11,4) = "case" │ └── end_keyword_loc: (11,35)-(11,38) = "end" @@ -345,8 +345,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (13,26)-(13,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (13,10)-(13,12) = "in" - │ │ └── then_loc: (13,21)-(13,25) = "then" + │ │ ├── in_keyword_loc: (13,10)-(13,12) = "in" + │ │ └── then_keyword_loc: (13,21)-(13,25) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (13,0)-(13,4) = "case" │ └── end_keyword_loc: (13,32)-(13,35) = "end" @@ -390,8 +390,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (15,25)-(15,29)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (15,10)-(15,12) = "in" - │ │ └── then_loc: (15,20)-(15,24) = "then" + │ │ ├── in_keyword_loc: (15,10)-(15,12) = "in" + │ │ └── then_keyword_loc: (15,20)-(15,24) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (15,0)-(15,4) = "case" │ └── end_keyword_loc: (15,31)-(15,34) = "end" @@ -433,8 +433,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (17,23)-(17,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (17,10)-(17,12) = "in" - │ │ └── then_loc: (17,18)-(17,22) = "then" + │ │ ├── in_keyword_loc: (17,10)-(17,12) = "in" + │ │ └── then_keyword_loc: (17,18)-(17,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (17,0)-(17,4) = "case" │ └── end_keyword_loc: (17,28)-(17,31) = "end" @@ -474,8 +474,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (19,22)-(19,25)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (19,10)-(19,12) = "in" - │ └── then_loc: (19,17)-(19,21) = "then" + │ ├── in_keyword_loc: (19,10)-(19,12) = "in" + │ └── then_keyword_loc: (19,17)-(19,21) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (19,0)-(19,4) = "case" └── end_keyword_loc: (19,27)-(19,30) = "end" diff --git a/snapshots/whitequark/pattern_matching_expr_in_paren.txt b/snapshots/whitequark/pattern_matching_expr_in_paren.txt index 397bac22c0..9243a5093c 100644 --- a/snapshots/whitequark/pattern_matching_expr_in_paren.txt +++ b/snapshots/whitequark/pattern_matching_expr_in_paren.txt @@ -37,8 +37,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,22)-(1,26)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,17)-(1,21) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,17)-(1,21) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,28)-(1,31) = "end" diff --git a/snapshots/whitequark/pattern_matching_hash.txt b/snapshots/whitequark/pattern_matching_hash.txt index ecedb02f0e..692ebf54ef 100644 --- a/snapshots/whitequark/pattern_matching_hash.txt +++ b/snapshots/whitequark/pattern_matching_hash.txt @@ -106,8 +106,8 @@ │ │ │ ├── closing_loc: ∅ │ │ │ ├── equal_loc: ∅ │ │ │ └── block: ∅ - │ │ ├── in_loc: (2,8)-(2,10) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (2,8)-(2,10) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (4,8)-(4,11) = "end" @@ -156,8 +156,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ FalseNode (location: (9,10)-(9,15)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (7,8)-(7,10) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (7,8)-(7,10) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (6,0)-(6,4) = "case" │ └── end_keyword_loc: (10,8)-(10,11) = "end" @@ -206,8 +206,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ FalseNode (location: (15,10)-(15,15)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (13,8)-(13,10) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (13,8)-(13,10) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (12,0)-(12,4) = "case" │ └── end_keyword_loc: (16,8)-(16,11) = "end" @@ -260,8 +260,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (21,10)-(21,14)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (19,8)-(19,10) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (19,8)-(19,10) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (18,0)-(18,4) = "case" │ └── end_keyword_loc: (22,8)-(22,11) = "end" @@ -310,8 +310,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ FalseNode (location: (27,10)-(27,15)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (25,8)-(25,10) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (25,8)-(25,10) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (24,0)-(24,4) = "case" │ └── end_keyword_loc: (28,8)-(28,11) = "end" @@ -350,8 +350,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (30,21)-(30,25)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (30,10)-(30,12) = "in" - │ │ └── then_loc: (30,16)-(30,20) = "then" + │ │ ├── in_keyword_loc: (30,10)-(30,12) = "in" + │ │ └── then_keyword_loc: (30,16)-(30,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (30,0)-(30,4) = "case" │ └── end_keyword_loc: (30,27)-(30,30) = "end" @@ -394,8 +394,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (32,22)-(32,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (32,10)-(32,12) = "in" - │ │ └── then_loc: (32,17)-(32,21) = "then" + │ │ ├── in_keyword_loc: (32,10)-(32,12) = "in" + │ │ └── then_keyword_loc: (32,17)-(32,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (32,0)-(32,4) = "case" │ └── end_keyword_loc: (32,28)-(32,31) = "end" @@ -444,8 +444,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (34,23)-(34,27)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (34,10)-(34,12) = "in" - │ │ └── then_loc: (34,18)-(34,22) = "then" + │ │ ├── in_keyword_loc: (34,10)-(34,12) = "in" + │ │ └── then_keyword_loc: (34,18)-(34,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (34,0)-(34,4) = "case" │ └── end_keyword_loc: (34,29)-(34,32) = "end" @@ -516,8 +516,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (36,32)-(36,36)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (36,10)-(36,12) = "in" - │ │ └── then_loc: (36,27)-(36,31) = "then" + │ │ ├── in_keyword_loc: (36,10)-(36,12) = "in" + │ │ └── then_keyword_loc: (36,27)-(36,31) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (36,0)-(36,4) = "case" │ └── end_keyword_loc: (36,38)-(36,41) = "end" @@ -580,8 +580,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (38,29)-(38,33)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (38,10)-(38,12) = "in" - │ │ └── then_loc: (38,24)-(38,28) = "then" + │ │ ├── in_keyword_loc: (38,10)-(38,12) = "in" + │ │ └── then_keyword_loc: (38,24)-(38,28) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (38,0)-(38,4) = "case" │ └── end_keyword_loc: (38,35)-(38,38) = "end" @@ -634,8 +634,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (40,21)-(40,25)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (40,10)-(40,12) = "in" - │ │ └── then_loc: (40,16)-(40,20) = "then" + │ │ ├── in_keyword_loc: (40,10)-(40,12) = "in" + │ │ └── then_keyword_loc: (40,16)-(40,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (40,0)-(40,4) = "case" │ └── end_keyword_loc: (40,27)-(40,30) = "end" @@ -706,8 +706,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (42,25)-(42,29)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (42,10)-(42,12) = "in" - │ │ └── then_loc: (42,20)-(42,24) = "then" + │ │ ├── in_keyword_loc: (42,10)-(42,12) = "in" + │ │ └── then_keyword_loc: (42,20)-(42,24) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (42,0)-(42,4) = "case" │ └── end_keyword_loc: (42,31)-(42,34) = "end" @@ -756,8 +756,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (44,27)-(44,31)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (44,10)-(44,12) = "in" - │ │ └── then_loc: (44,22)-(44,26) = "then" + │ │ ├── in_keyword_loc: (44,10)-(44,12) = "in" + │ │ └── then_keyword_loc: (44,22)-(44,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (44,0)-(44,4) = "case" │ └── end_keyword_loc: (44,33)-(44,36) = "end" @@ -806,8 +806,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (46,28)-(46,32)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (46,10)-(46,12) = "in" - │ │ └── then_loc: (46,23)-(46,27) = "then" + │ │ ├── in_keyword_loc: (46,10)-(46,12) = "in" + │ │ └── then_keyword_loc: (46,23)-(46,27) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (46,0)-(46,4) = "case" │ └── end_keyword_loc: (46,34)-(46,37) = "end" @@ -842,8 +842,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (48,21)-(48,25)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (48,10)-(48,12) = "in" - │ └── then_loc: (48,16)-(48,20) = "then" + │ ├── in_keyword_loc: (48,10)-(48,12) = "in" + │ └── then_keyword_loc: (48,16)-(48,20) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (48,0)-(48,4) = "case" └── end_keyword_loc: (48,27)-(48,30) = "end" diff --git a/snapshots/whitequark/pattern_matching_if_unless_modifiers.txt b/snapshots/whitequark/pattern_matching_if_unless_modifiers.txt index 90761ce455..20e9fdf78c 100644 --- a/snapshots/whitequark/pattern_matching_if_unless_modifiers.txt +++ b/snapshots/whitequark/pattern_matching_if_unless_modifiers.txt @@ -46,8 +46,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (1,24)-(1,27)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,29)-(1,32) = "end" @@ -71,7 +71,7 @@ │ ├── pattern: │ │ @ UnlessNode (location: (3,13)-(3,26)) │ │ ├── flags: newline - │ │ ├── keyword_loc: (3,15)-(3,21) = "unless" + │ │ ├── unless_keyword_loc: (3,15)-(3,21) = "unless" │ │ ├── predicate: │ │ │ @ TrueNode (location: (3,22)-(3,26)) │ │ │ └── flags: static_literal @@ -92,8 +92,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (3,28)-(3,31)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (3,10)-(3,12) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (3,0)-(3,4) = "case" └── end_keyword_loc: (3,33)-(3,36) = "end" diff --git a/snapshots/whitequark/pattern_matching_implicit_array_match.txt b/snapshots/whitequark/pattern_matching_implicit_array_match.txt index cd67a840a0..b9b66ea09c 100644 --- a/snapshots/whitequark/pattern_matching_implicit_array_match.txt +++ b/snapshots/whitequark/pattern_matching_implicit_array_match.txt @@ -41,8 +41,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (1,20)-(1,23)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,15)-(1,19) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,15)-(1,19) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,25)-(1,28) = "end" @@ -86,8 +86,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (3,21)-(3,24)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,16)-(3,20) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,16)-(3,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,26)-(3,29) = "end" @@ -139,8 +139,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (5,27)-(5,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: (5,22)-(5,26) = "then" + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: (5,22)-(5,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,32)-(5,35) = "end" @@ -200,8 +200,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (7,33)-(7,36)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (7,10)-(7,12) = "in" - │ │ └── then_loc: (7,28)-(7,32) = "then" + │ │ ├── in_keyword_loc: (7,10)-(7,12) = "in" + │ │ └── then_keyword_loc: (7,28)-(7,32) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (7,0)-(7,4) = "case" │ └── end_keyword_loc: (7,38)-(7,41) = "end" @@ -253,8 +253,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (9,27)-(9,30)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (9,10)-(9,12) = "in" - │ │ └── then_loc: (9,22)-(9,26) = "then" + │ │ ├── in_keyword_loc: (9,10)-(9,12) = "in" + │ │ └── then_keyword_loc: (9,22)-(9,26) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (9,32)-(9,35) = "end" @@ -296,8 +296,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (11,21)-(11,24)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (11,10)-(11,12) = "in" - │ │ └── then_loc: (11,16)-(11,20) = "then" + │ │ ├── in_keyword_loc: (11,10)-(11,12) = "in" + │ │ └── then_keyword_loc: (11,16)-(11,20) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (11,0)-(11,4) = "case" │ └── end_keyword_loc: (11,26)-(11,29) = "end" @@ -341,8 +341,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (13,23)-(13,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (13,10)-(13,12) = "in" - │ │ └── then_loc: (13,18)-(13,22) = "then" + │ │ ├── in_keyword_loc: (13,10)-(13,12) = "in" + │ │ └── then_keyword_loc: (13,18)-(13,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (13,0)-(13,4) = "case" │ └── end_keyword_loc: (13,28)-(13,31) = "end" @@ -388,8 +388,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (15,24)-(15,27)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (15,10)-(15,12) = "in" - │ └── then_loc: (15,19)-(15,23) = "then" + │ ├── in_keyword_loc: (15,10)-(15,12) = "in" + │ └── then_keyword_loc: (15,19)-(15,23) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (15,0)-(15,4) = "case" └── end_keyword_loc: (15,29)-(15,32) = "end" diff --git a/snapshots/whitequark/pattern_matching_keyword_variable.txt b/snapshots/whitequark/pattern_matching_keyword_variable.txt index 804f474f9c..e7110618bd 100644 --- a/snapshots/whitequark/pattern_matching_keyword_variable.txt +++ b/snapshots/whitequark/pattern_matching_keyword_variable.txt @@ -31,8 +31,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,23)-(1,27)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,18)-(1,22) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,18)-(1,22) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,29)-(1,32) = "end" diff --git a/snapshots/whitequark/pattern_matching_lambda.txt b/snapshots/whitequark/pattern_matching_lambda.txt index 4d9951c036..1fecf8f649 100644 --- a/snapshots/whitequark/pattern_matching_lambda.txt +++ b/snapshots/whitequark/pattern_matching_lambda.txt @@ -43,8 +43,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,27)-(1,31)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,22)-(1,26) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,22)-(1,26) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,33)-(1,36) = "end" diff --git a/snapshots/whitequark/pattern_matching_match_alt.txt b/snapshots/whitequark/pattern_matching_match_alt.txt index f8e8f0d9c6..30261bc604 100644 --- a/snapshots/whitequark/pattern_matching_match_alt.txt +++ b/snapshots/whitequark/pattern_matching_match_alt.txt @@ -40,8 +40,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,24)-(1,28)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,19)-(1,23) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,19)-(1,23) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,30)-(1,33) = "end" diff --git a/snapshots/whitequark/pattern_matching_match_as.txt b/snapshots/whitequark/pattern_matching_match_as.txt index 5494319007..1327fc25af 100644 --- a/snapshots/whitequark/pattern_matching_match_as.txt +++ b/snapshots/whitequark/pattern_matching_match_as.txt @@ -41,8 +41,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,25)-(1,29)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,20)-(1,24) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,20)-(1,24) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,31)-(1,34) = "end" diff --git a/snapshots/whitequark/pattern_matching_nil_pattern.txt b/snapshots/whitequark/pattern_matching_nil_pattern.txt index 79a1b16334..0b83e8249a 100644 --- a/snapshots/whitequark/pattern_matching_nil_pattern.txt +++ b/snapshots/whitequark/pattern_matching_nil_pattern.txt @@ -40,8 +40,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (1,24)-(1,28)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,19)-(1,23) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,19)-(1,23) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,30)-(1,33) = "end" diff --git a/snapshots/whitequark/pattern_matching_no_body.txt b/snapshots/whitequark/pattern_matching_no_body.txt index 3a656ba5af..376d8ed3e0 100644 --- a/snapshots/whitequark/pattern_matching_no_body.txt +++ b/snapshots/whitequark/pattern_matching_no_body.txt @@ -27,8 +27,8 @@ │ │ ├── flags: static_literal, decimal │ │ └── value: 1 │ ├── statements: ∅ - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: ∅ + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: ∅ ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,16)-(1,19) = "end" diff --git a/snapshots/whitequark/pattern_matching_ranges.txt b/snapshots/whitequark/pattern_matching_ranges.txt index bd92db0e12..6951f5284d 100644 --- a/snapshots/whitequark/pattern_matching_ranges.txt +++ b/snapshots/whitequark/pattern_matching_ranges.txt @@ -37,8 +37,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (1,23)-(1,27)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: (1,18)-(1,22) = "then" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: (1,18)-(1,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,29)-(1,32) = "end" @@ -74,8 +74,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (3,22)-(3,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,17)-(3,21) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,17)-(3,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,28)-(3,31) = "end" @@ -111,8 +111,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (5,22)-(5,26)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: (5,17)-(5,21) = "then" + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: (5,17)-(5,21) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (5,28)-(5,31) = "end" @@ -148,8 +148,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (7,23)-(7,27)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (7,10)-(7,12) = "in" - │ │ └── then_loc: (7,18)-(7,22) = "then" + │ │ ├── in_keyword_loc: (7,10)-(7,12) = "in" + │ │ └── then_keyword_loc: (7,18)-(7,22) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (7,0)-(7,4) = "case" │ └── end_keyword_loc: (7,29)-(7,32) = "end" @@ -188,8 +188,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ TrueNode (location: (9,24)-(9,28)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (9,10)-(9,12) = "in" - │ │ └── then_loc: (9,19)-(9,23) = "then" + │ │ ├── in_keyword_loc: (9,10)-(9,12) = "in" + │ │ └── then_keyword_loc: (9,19)-(9,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (9,0)-(9,4) = "case" │ └── end_keyword_loc: (9,30)-(9,33) = "end" @@ -228,8 +228,8 @@ │ │ └── body: (length: 1) │ │ └── @ TrueNode (location: (11,23)-(11,27)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (11,10)-(11,12) = "in" - │ └── then_loc: (11,18)-(11,22) = "then" + │ ├── in_keyword_loc: (11,10)-(11,12) = "in" + │ └── then_keyword_loc: (11,18)-(11,22) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (11,0)-(11,4) = "case" └── end_keyword_loc: (11,29)-(11,32) = "end" diff --git a/snapshots/whitequark/pattern_matching_single_line.txt b/snapshots/whitequark/pattern_matching_single_line.txt index f11ec00951..5968124385 100644 --- a/snapshots/whitequark/pattern_matching_single_line.txt +++ b/snapshots/whitequark/pattern_matching_single_line.txt @@ -48,7 +48,7 @@ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: (3,5)-(3,6) = "[" │ │ └── closing_loc: (3,7)-(3,8) = "]" - │ └── operator_loc: (3,2)-(3,4) = "in" + │ └── keyword_loc: (3,2)-(3,4) = "in" └── @ LocalVariableReadNode (location: (3,10)-(3,11)) ├── flags: newline ├── name: :a diff --git a/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt b/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt index 51542e9dd2..95ca9ee25c 100644 --- a/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt +++ b/snapshots/whitequark/pattern_matching_single_line_allowed_omission_of_parentheses.txt @@ -72,7 +72,7 @@ │ │ ├── posts: (length: 0) │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ - │ └── operator_loc: (3,7)-(3,9) = "in" + │ └── keyword_loc: (3,7)-(3,9) = "in" ├── @ LocalVariableReadNode (location: (3,16)-(3,17)) │ ├── flags: newline │ ├── name: :a @@ -178,7 +178,7 @@ │ │ ├── rest: ∅ │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ - │ └── operator_loc: (7,7)-(7,9) = "in" + │ └── keyword_loc: (7,7)-(7,9) = "in" ├── @ LocalVariableReadNode (location: (7,14)-(7,15)) │ ├── flags: newline │ ├── name: :a @@ -284,7 +284,7 @@ │ │ ├── rest: ∅ │ │ ├── opening_loc: ∅ │ │ └── closing_loc: ∅ - │ └── operator_loc: (11,14)-(11,16) = "in" + │ └── keyword_loc: (11,14)-(11,16) = "in" └── @ LocalVariableReadNode (location: (11,29)-(11,34)) ├── flags: newline ├── name: :value diff --git a/snapshots/whitequark/pattern_matching_single_match.txt b/snapshots/whitequark/pattern_matching_single_match.txt index bc0bc99575..77cebeb6ec 100644 --- a/snapshots/whitequark/pattern_matching_single_match.txt +++ b/snapshots/whitequark/pattern_matching_single_match.txt @@ -35,8 +35,8 @@ │ │ ├── flags: newline │ │ ├── name: :x │ │ └── depth: 0 - │ ├── in_loc: (1,10)-(1,12) = "in" - │ └── then_loc: (1,15)-(1,19) = "then" + │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ └── then_keyword_loc: (1,15)-(1,19) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (1,0)-(1,4) = "case" └── end_keyword_loc: (1,23)-(1,26) = "end" diff --git a/snapshots/whitequark/pin_expr.txt b/snapshots/whitequark/pin_expr.txt index 4eb7d44699..17edf47e84 100644 --- a/snapshots/whitequark/pin_expr.txt +++ b/snapshots/whitequark/pin_expr.txt @@ -31,8 +31,8 @@ │ │ │ │ └── name: :$TestPatternMatching │ │ │ └── operator_loc: (1,13)-(1,14) = "^" │ │ ├── statements: ∅ - │ │ ├── in_loc: (1,10)-(1,12) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (1,0)-(1,4) = "case" │ └── end_keyword_loc: (1,36)-(1,39) = "end" @@ -86,8 +86,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (3,25)-(3,28)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (3,10)-(3,12) = "in" - │ │ └── then_loc: (3,20)-(3,24) = "then" + │ │ ├── in_keyword_loc: (3,10)-(3,12) = "in" + │ │ └── then_keyword_loc: (3,20)-(3,24) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (3,0)-(3,4) = "case" │ └── end_keyword_loc: (3,30)-(3,33) = "end" @@ -119,8 +119,8 @@ │ │ │ ├── lparen_loc: (5,14)-(5,15) = "(" │ │ │ └── rparen_loc: (6,0)-(6,1) = ")" │ │ ├── statements: ∅ - │ │ ├── in_loc: (5,10)-(5,12) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (5,10)-(5,12) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (5,0)-(5,4) = "case" │ └── end_keyword_loc: (6,3)-(6,6) = "end" @@ -157,8 +157,8 @@ │ │ │ └── body: (length: 1) │ │ │ └── @ NilNode (location: (8,24)-(8,27)) │ │ │ └── flags: newline, static_literal - │ │ ├── in_loc: (8,10)-(8,12) = "in" - │ │ └── then_loc: (8,19)-(8,23) = "then" + │ │ ├── in_keyword_loc: (8,10)-(8,12) = "in" + │ │ └── then_keyword_loc: (8,19)-(8,23) = "then" │ ├── else_clause: ∅ │ ├── case_keyword_loc: (8,0)-(8,4) = "case" │ └── end_keyword_loc: (8,29)-(8,32) = "end" @@ -188,8 +188,8 @@ │ │ │ │ └── name: :@@TestPatternMatching │ │ │ └── operator_loc: (10,13)-(10,14) = "^" │ │ ├── statements: ∅ - │ │ ├── in_loc: (10,10)-(10,12) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (10,10)-(10,12) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (10,0)-(10,4) = "case" │ └── end_keyword_loc: (10,37)-(10,40) = "end" @@ -219,8 +219,8 @@ │ │ │ │ └── name: :@a │ │ │ └── operator_loc: (12,13)-(12,14) = "^" │ │ ├── statements: ∅ - │ │ ├── in_loc: (12,10)-(12,12) = "in" - │ │ └── then_loc: ∅ + │ │ ├── in_keyword_loc: (12,10)-(12,12) = "in" + │ │ └── then_keyword_loc: ∅ │ ├── else_clause: ∅ │ ├── case_keyword_loc: (12,0)-(12,4) = "case" │ └── end_keyword_loc: (12,18)-(12,21) = "end" @@ -275,8 +275,8 @@ │ │ └── body: (length: 1) │ │ └── @ NilNode (location: (14,33)-(14,36)) │ │ └── flags: newline, static_literal - │ ├── in_loc: (14,10)-(14,12) = "in" - │ └── then_loc: (14,28)-(14,32) = "then" + │ ├── in_keyword_loc: (14,10)-(14,12) = "in" + │ └── then_keyword_loc: (14,28)-(14,32) = "then" ├── else_clause: ∅ ├── case_keyword_loc: (14,0)-(14,4) = "case" └── end_keyword_loc: (14,38)-(14,41) = "end" diff --git a/snapshots/whitequark/unless.txt b/snapshots/whitequark/unless.txt index 7c81d72e27..767cefd280 100644 --- a/snapshots/whitequark/unless.txt +++ b/snapshots/whitequark/unless.txt @@ -7,7 +7,7 @@ └── body: (length: 2) ├── @ UnlessNode (location: (1,0)-(1,24)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,6) = "unless" + │ ├── unless_keyword_loc: (1,0)-(1,6) = "unless" │ ├── predicate: │ │ @ CallNode (location: (1,7)-(1,10)) │ │ ├── flags: variable_call, ignore_visibility @@ -40,7 +40,7 @@ │ └── end_keyword_loc: (1,21)-(1,24) = "end" └── @ UnlessNode (location: (3,0)-(3,20)) ├── flags: newline - ├── keyword_loc: (3,0)-(3,6) = "unless" + ├── unless_keyword_loc: (3,0)-(3,6) = "unless" ├── predicate: │ @ CallNode (location: (3,7)-(3,10)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/unless_else.txt b/snapshots/whitequark/unless_else.txt index 77807c7d24..8b0b41ab0e 100644 --- a/snapshots/whitequark/unless_else.txt +++ b/snapshots/whitequark/unless_else.txt @@ -7,7 +7,7 @@ └── body: (length: 2) ├── @ UnlessNode (location: (1,0)-(1,34)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,6) = "unless" + │ ├── unless_keyword_loc: (1,0)-(1,6) = "unless" │ ├── predicate: │ │ @ CallNode (location: (1,7)-(1,10)) │ │ ├── flags: variable_call, ignore_visibility @@ -59,7 +59,7 @@ │ └── end_keyword_loc: (1,31)-(1,34) = "end" └── @ UnlessNode (location: (3,0)-(3,30)) ├── flags: newline - ├── keyword_loc: (3,0)-(3,6) = "unless" + ├── unless_keyword_loc: (3,0)-(3,6) = "unless" ├── predicate: │ @ CallNode (location: (3,7)-(3,10)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/unless_mod.txt b/snapshots/whitequark/unless_mod.txt index 0a0e2f4917..1be2323db0 100644 --- a/snapshots/whitequark/unless_mod.txt +++ b/snapshots/whitequark/unless_mod.txt @@ -7,7 +7,7 @@ └── body: (length: 1) └── @ UnlessNode (location: (1,0)-(1,14)) ├── flags: newline - ├── keyword_loc: (1,4)-(1,10) = "unless" + ├── unless_keyword_loc: (1,4)-(1,10) = "unless" ├── predicate: │ @ CallNode (location: (1,11)-(1,14)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/until.txt b/snapshots/whitequark/until.txt index 2b31c70613..401979d8d1 100644 --- a/snapshots/whitequark/until.txt +++ b/snapshots/whitequark/until.txt @@ -7,9 +7,9 @@ └── body: (length: 2) ├── @ UntilNode (location: (1,0)-(1,21)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,5) = "until" + │ ├── until_keyword_loc: (1,0)-(1,5) = "until" │ ├── do_keyword_loc: (1,10)-(1,12) = "do" - │ ├── closing_loc: (1,18)-(1,21) = "end" + │ ├── end_keyword_loc: (1,18)-(1,21) = "end" │ ├── predicate: │ │ @ CallNode (location: (1,6)-(1,9)) │ │ ├── flags: variable_call, ignore_visibility @@ -39,9 +39,9 @@ │ └── block: ∅ └── @ UntilNode (location: (3,0)-(3,19)) ├── flags: newline - ├── keyword_loc: (3,0)-(3,5) = "until" + ├── until_keyword_loc: (3,0)-(3,5) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,16)-(3,19) = "end" + ├── end_keyword_loc: (3,16)-(3,19) = "end" ├── predicate: │ @ CallNode (location: (3,6)-(3,9)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/until_mod.txt b/snapshots/whitequark/until_mod.txt index dab63f0247..5c1d3390b0 100644 --- a/snapshots/whitequark/until_mod.txt +++ b/snapshots/whitequark/until_mod.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ UntilNode (location: (1,0)-(1,14)) ├── flags: newline - ├── keyword_loc: (1,5)-(1,10) = "until" + ├── until_keyword_loc: (1,5)-(1,10) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ CallNode (location: (1,11)-(1,14)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/until_post.txt b/snapshots/whitequark/until_post.txt index 2b65a3125a..1485391915 100644 --- a/snapshots/whitequark/until_post.txt +++ b/snapshots/whitequark/until_post.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ UntilNode (location: (1,0)-(1,24)) ├── flags: newline, begin_modifier - ├── keyword_loc: (1,15)-(1,20) = "until" + ├── until_keyword_loc: (1,15)-(1,20) = "until" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ CallNode (location: (1,21)-(1,24)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/when_multi.txt b/snapshots/whitequark/when_multi.txt index 2aab67f1e3..392ac2c74c 100644 --- a/snapshots/whitequark/when_multi.txt +++ b/snapshots/whitequark/when_multi.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,10)-(1,32)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,10)-(1,14) = "when" + │ ├── when_keyword_loc: (1,10)-(1,14) = "when" │ ├── conditions: (length: 2) │ │ ├── @ StringNode (location: (1,15)-(1,20)) │ │ │ ├── flags: static_literal, frozen diff --git a/snapshots/whitequark/when_splat.txt b/snapshots/whitequark/when_splat.txt index 34c8032f77..377860d12a 100644 --- a/snapshots/whitequark/when_splat.txt +++ b/snapshots/whitequark/when_splat.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 2) │ ├── @ WhenNode (location: (1,10)-(1,27)) │ │ ├── flags: ∅ - │ │ ├── keyword_loc: (1,10)-(1,14) = "when" + │ │ ├── when_keyword_loc: (1,10)-(1,14) = "when" │ │ ├── conditions: (length: 2) │ │ │ ├── @ IntegerNode (location: (1,15)-(1,16)) │ │ │ │ ├── flags: static_literal, decimal @@ -60,7 +60,7 @@ │ │ └── block: ∅ │ └── @ WhenNode (location: (1,29)-(1,38)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,29)-(1,33) = "when" + │ ├── when_keyword_loc: (1,29)-(1,33) = "when" │ ├── conditions: (length: 1) │ │ └── @ SplatNode (location: (1,34)-(1,38)) │ │ ├── flags: ∅ diff --git a/snapshots/whitequark/when_then.txt b/snapshots/whitequark/when_then.txt index cf9e0c23ae..6e2e825547 100644 --- a/snapshots/whitequark/when_then.txt +++ b/snapshots/whitequark/when_then.txt @@ -22,7 +22,7 @@ ├── conditions: (length: 1) │ └── @ WhenNode (location: (1,10)-(1,29)) │ ├── flags: ∅ - │ ├── keyword_loc: (1,10)-(1,14) = "when" + │ ├── when_keyword_loc: (1,10)-(1,14) = "when" │ ├── conditions: (length: 1) │ │ └── @ StringNode (location: (1,15)-(1,20)) │ │ ├── flags: static_literal, frozen diff --git a/snapshots/whitequark/while.txt b/snapshots/whitequark/while.txt index 41b104bd6d..ee6a42768c 100644 --- a/snapshots/whitequark/while.txt +++ b/snapshots/whitequark/while.txt @@ -7,9 +7,9 @@ └── body: (length: 2) ├── @ WhileNode (location: (1,0)-(1,21)) │ ├── flags: newline - │ ├── keyword_loc: (1,0)-(1,5) = "while" + │ ├── while_keyword_loc: (1,0)-(1,5) = "while" │ ├── do_keyword_loc: (1,10)-(1,12) = "do" - │ ├── closing_loc: (1,18)-(1,21) = "end" + │ ├── end_keyword_loc: (1,18)-(1,21) = "end" │ ├── predicate: │ │ @ CallNode (location: (1,6)-(1,9)) │ │ ├── flags: variable_call, ignore_visibility @@ -39,9 +39,9 @@ │ └── block: ∅ └── @ WhileNode (location: (3,0)-(3,19)) ├── flags: newline - ├── keyword_loc: (3,0)-(3,5) = "while" + ├── while_keyword_loc: (3,0)-(3,5) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: (3,16)-(3,19) = "end" + ├── end_keyword_loc: (3,16)-(3,19) = "end" ├── predicate: │ @ CallNode (location: (3,6)-(3,9)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/while_mod.txt b/snapshots/whitequark/while_mod.txt index 41782c4b64..c25464e726 100644 --- a/snapshots/whitequark/while_mod.txt +++ b/snapshots/whitequark/while_mod.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ WhileNode (location: (1,0)-(1,14)) ├── flags: newline - ├── keyword_loc: (1,5)-(1,10) = "while" + ├── while_keyword_loc: (1,5)-(1,10) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ CallNode (location: (1,11)-(1,14)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/whitequark/while_post.txt b/snapshots/whitequark/while_post.txt index 4a16f63a7c..2dc7e429b5 100644 --- a/snapshots/whitequark/while_post.txt +++ b/snapshots/whitequark/while_post.txt @@ -7,9 +7,9 @@ └── body: (length: 1) └── @ WhileNode (location: (1,0)-(1,24)) ├── flags: newline, begin_modifier - ├── keyword_loc: (1,15)-(1,20) = "while" + ├── while_keyword_loc: (1,15)-(1,20) = "while" ├── do_keyword_loc: ∅ - ├── closing_loc: ∅ + ├── end_keyword_loc: ∅ ├── predicate: │ @ CallNode (location: (1,21)-(1,24)) │ ├── flags: variable_call, ignore_visibility diff --git a/snapshots/write_command_operator.txt b/snapshots/write_command_operator.txt index f1d92729ed..c6403013e9 100644 --- a/snapshots/write_command_operator.txt +++ b/snapshots/write_command_operator.txt @@ -81,4 +81,4 @@ │ @ ConstantReadNode (location: (3,21)-(3,24)) │ ├── flags: ∅ │ └── name: :BAR - └── operator_loc: (3,18)-(3,20) = "in" + └── keyword_loc: (3,18)-(3,20) = "in"