prism 1.8.1 → 2.0.0.rc1

data/lib/prism/translation/ripper.rb

@@ -22,22 +22,10 @@ module Prism
     # - on_comma
     # - on_ignored_nl
     # - on_ignored_sp
-    # - on_kw
-    # - on_label_end
-    # - on_lbrace
-    # - on_lbracket
-    # - on_lparen
     # - on_nl
-    # - on_op
     # - on_operator_ambiguous
-    # - on_rbrace
-    # - on_rbracket
-    # - on_rparen
     # - on_semicolon
     # - on_sp
-    # - on_symbeg
-    # - on_tstring_beg
-    # - on_tstring_end
     #
     class Ripper < Compiler
       # Parses the given Ruby program read from +src+.
@@ -69,7 +57,8 @@ module Prism
       #          [[1, 13], :on_kw,     "end", END      ]]
       #
       def self.lex(src, filename = "-", lineno = 1, raise_errors: false)
-        result = Prism.lex_compat(src, filepath: filename, line: lineno, version: "current")
+        coerced = coerce_source(src)
+        result = Prism.lex_compat(coerced, filepath: filename, line: lineno, version: "current", encoding: coerced.encoding)
 
         if result.failure? && raise_errors
           raise SyntaxError, result.errors.first.message
@@ -78,6 +67,34 @@ module Prism
         end
       end
 
+      # Tokenizes the Ruby program and returns an array of strings.
+      # The +filename+ and +lineno+ arguments are mostly ignored, since the
+      # return value is just the tokenized input.
+      # By default, this method does not handle syntax errors in +src+,
+      # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+.
+      #
+      #   p Ripper.tokenize("def m(a) nil end")
+      #      # => ["def", " ", "m", "(", "a", ")", " ", "nil", " ", "end"]
+      #
+      def self.tokenize(...)
+        lex(...).map { |token| token[2] }
+      end
+
+      # Mirros the various lex_types that ripper supports
+      def self.coerce_source(source) # :nodoc:
+        if source.is_a?(IO)
+          source.read
+        elsif source.respond_to?(:gets)
+          src = +""
+          while line = source.gets
+            src << line
+          end
+          src
+        else
+          source.to_str
+        end
+      end
+
       # This contains a table of all of the parser events and their
       # corresponding arity.
       PARSER_EVENT_TABLE = {
@@ -330,7 +347,7 @@ module Prism
         "__ENCODING__",
         "__FILE__",
         "__LINE__"
-      ]
+      ].to_set
 
       # A list of all of the Ruby binary operators.
       BINARY_OPERATORS = [
@@ -355,7 +372,7 @@ module Prism
         :/,
         :*,
         :**
-      ]
+      ].to_set
 
       private_constant :KEYWORDS, :BINARY_OPERATORS
 
@@ -424,10 +441,69 @@ module Prism
         end
       end
 
+      autoload :Filter, "prism/translation/ripper/filter"
       autoload :Lexer, "prism/translation/ripper/lexer"
       autoload :SexpBuilder, "prism/translation/ripper/sexp"
       autoload :SexpBuilderPP, "prism/translation/ripper/sexp"
 
+      # Provides optimized access to line and column information.
+      # Ripper bounds are mostly accessed in a linear fashion, so
+      # we can try a linear scan first and fall back to binary search.
+      class LineAndColumnCache # :nodoc:
+        # How many should it look ahead/behind before falling back to binary searching.
+        WINDOW = 8
+        private_constant :WINDOW
+
+        #: (Source source) -> void
+        def initialize(source)
+          @source = source
+          @offsets = source.offsets
+          @hint = 0
+        end
+
+        #: (Integer byte_offset) -> [Integer, Integer]
+        def line_and_column(byte_offset)
+          @hint = new_hint(byte_offset) || @source.find_line(byte_offset)
+          return [@hint + @source.start_line, byte_offset - @offsets[@hint]]
+        end
+
+        private
+
+        def new_hint(byte_offset)
+          if @offsets[@hint] <= byte_offset
+            # Same line?
+            if (@hint + 1 >= @offsets.size || @offsets[@hint + 1] > byte_offset)
+              return @hint
+            end
+
+            # Scan forwards
+            limit = [@hint + WINDOW + 1, @offsets.size].min
+            idx = @hint + 1
+            while idx < limit
+              if @offsets[idx] > byte_offset
+                return idx - 1
+              end
+              if @offsets[idx] == byte_offset
+                return idx
+              end
+              idx += 1
+            end
+          else
+            # Scan backwards
+            limit = @hint > WINDOW ? @hint - WINDOW : 0
+            idx = @hint
+            while idx >= limit + 1
+              if @offsets[idx - 1] <= byte_offset
+                return idx - 1
+              end
+              idx -= 1
+            end
+          end
+
+          nil
+        end
+      end
+
       # :stopdoc:
       # This is not part of the public API but used by some gems.
 
@@ -461,16 +537,17 @@ module Prism
       # The current line number of the parser.
       attr_reader :lineno
 
-      # The current column number of the parser.
+      # The current column in bytes of the parser.
       attr_reader :column
 
       # Create a new Translation::Ripper object with the given source.
       def initialize(source, filename = "(ripper)", lineno = 1)
-        @source = source
+        @source = Ripper.coerce_source(source)
         @filename = filename
         @lineno = lineno
         @column = 0
         @result = nil
+        @line_and_column_cache = nil
       end
 
       ##########################################################################
@@ -489,7 +566,12 @@ module Prism
           bounds(location)
 
           if comment.is_a?(InlineComment)
-            on_comment(comment.slice)
+            # Inline comments always contain a newline if the line itself contains it
+            if result.source.source.bytesize > comment.location.end_offset
+              on_comment("#{comment.slice}\n")
+            else
+              on_comment(comment.slice)
+            end
           else
             offset = location.start_offset
             lines = comment.slice.lines
@@ -566,13 +648,28 @@ module Prism
         end
       end
 
+      # Return encoding of the source.
+      def encoding
+        result.source.encoding
+      end
+
+      # Return true if parsed source ended by `__END__`.
+      def end_seen?
+        !!result.data_loc
+      end
+
       ##########################################################################
       # Visitor methods
       ##########################################################################
 
+      # :stopdoc:
+
       # alias foo bar
       # ^^^^^^^^^^^^^
       def visit_alias_method_node(node)
+        bounds(node.keyword_loc)
+        on_kw("alias")
+
         new_name = visit(node.new_name)
         old_name = visit(node.old_name)
 
@@ -583,6 +680,9 @@ module Prism
       # alias $foo $bar
       # ^^^^^^^^^^^^^^^
       def visit_alias_global_variable_node(node)
+        bounds(node.keyword_loc)
+        on_kw("alias")
+
         new_name = visit_alias_global_variable_node_value(node.new_name)
         old_name = visit_alias_global_variable_node_value(node.old_name)
 
@@ -608,6 +708,10 @@ module Prism
       #        ^^^^^^^^^
       def visit_alternation_pattern_node(node)
         left = visit_pattern_node(node.left)
+
+        bounds(node.operator_loc)
+        on_op("|")
+
         right = visit_pattern_node(node.right)
 
         bounds(node.location)
@@ -618,7 +722,13 @@ module Prism
       # parenthesis node that can be used to wrap patterns.
       private def visit_pattern_node(node)
         if node.is_a?(ParenthesesNode)
-          visit(node.body)
+          bounds(node.opening_loc)
+          on_lparen("(")
+          result = visit(node.body)
+          bounds(node.closing_loc)
+          on_rparen(")")
+
+          result
         else
           visit(node)
         end
@@ -628,6 +738,14 @@ module Prism
       # ^^^^^^^
       def visit_and_node(node)
         left = visit(node.left)
+
+        bounds(node.operator_loc)
+        if node.operator == "and"
+          on_kw("and")
+        else
+          on_op("&&")
+        end
+
         right = visit(node.right)
 
         bounds(node.location)
@@ -655,6 +773,8 @@ module Prism
             previous = element
           end
 
+          visit_words_sep(opening_loc, node.elements.last, node.closing_loc)
+
           bounds(node.closing_loc)
           on_tstring_end(node.closing)
         when /^%i/
@@ -669,11 +789,13 @@ module Prism
             visit_words_sep(opening_loc, previous, element)
 
             bounds(element.location)
-            elements = on_qsymbols_add(elements, on_tstring_content(element.value))
+            elements = on_qsymbols_add(elements, on_tstring_content(element.content))
 
             previous = element
           end
 
+          visit_words_sep(opening_loc, node.elements.last, node.closing_loc)
+
           bounds(node.closing_loc)
           on_tstring_end(node.closing)
         when /^%W/
@@ -711,6 +833,8 @@ module Prism
             previous = element
           end
 
+          visit_words_sep(opening_loc, node.elements.last, node.closing_loc)
+
           bounds(node.closing_loc)
           on_tstring_end(node.closing)
         when /^%I/
@@ -729,7 +853,7 @@ module Prism
               on_symbols_add(
                 elements,
                 if element.is_a?(SymbolNode)
-                  on_word_add(on_word_new, on_tstring_content(element.value))
+                  on_word_add(on_word_new, on_tstring_content(element.content))
                 else
                   element.parts.inject(on_word_new) do |word, part|
                     word_part =
@@ -748,6 +872,8 @@ module Prism
             previous = element
           end
 
+          visit_words_sep(opening_loc, node.elements.last, node.closing_loc)
+
           bounds(node.closing_loc)
           on_tstring_end(node.closing)
         else
@@ -764,15 +890,21 @@ module Prism
         on_array(elements)
       end
 
-      # Dispatch a words_sep event that contains the space between the elements
+      # Dispatch words_sep events that contains the whitespace between the elements
       # of list literals.
       private def visit_words_sep(opening_loc, previous, current)
-        end_offset = (previous.nil? ? opening_loc : previous.location).end_offset
-        start_offset = current.location.start_offset
-
-        if end_offset != start_offset
-          bounds(current.location.copy(start_offset: end_offset))
-          on_words_sep(source.byteslice(end_offset...start_offset))
+        start_offset = (previous.nil? ? opening_loc : previous.location).end_offset
+        end_offset = current.start_offset
+        length = end_offset - start_offset
+
+        if length > 0
+          whitespace = source.byteslice(start_offset, length)
+          current_offset = start_offset
+          whitespace.each_line do |part|
+            bounds(opening_loc.copy(start_offset: current_offset, length: part.bytesize))
+            on_words_sep(part)
+            current_offset += part.bytesize
+          end
         end
       end
 
@@ -798,9 +930,18 @@ module Prism
       #        ^^^^^
       def visit_array_pattern_node(node)
         constant = visit(node.constant)
+
+        if node.opening_loc
+          bounds(node.opening_loc)
+          node.opening == "[" ? on_lbracket("[") : on_lparen("(")
+        end
+
         requireds = visit_all(node.requireds) if node.requireds.any?
         rest =
           if (rest_node = node.rest).is_a?(SplatNode)
+            bounds(rest_node.operator_loc)
+            on_op("*")
+
             if rest_node.expression.nil?
               bounds(rest_node.location)
               on_var_field(nil)
@@ -811,6 +952,10 @@ module Prism
 
         posts = visit_all(node.posts) if node.posts.any?
 
+        if node.closing_loc
+          bounds(node.closing_loc)
+          node.closing == "]" ? on_rbracket("]") : on_rparen(")")
+        end
         bounds(node.location)
         on_aryptn(constant, requireds, rest, posts)
       end
@@ -826,6 +971,12 @@ module Prism
       #   ^^^^
       def visit_assoc_node(node)
         key = visit(node.key)
+
+        if node.operator_loc
+          bounds(node.operator_loc)
+          on_op("=>")
+        end
+
         value = visit(node.value)
 
         bounds(node.location)
@@ -838,6 +989,9 @@ module Prism
       # { **foo }
       #   ^^^^^
       def visit_assoc_splat_node(node)
+        bounds(node.operator_loc)
+        on_op("**")
+
         value = visit(node.value)
 
         bounds(node.location)
@@ -854,8 +1008,18 @@ module Prism
       # begin end
       # ^^^^^^^^^
       def visit_begin_node(node)
+        if node.begin_keyword_loc
+          bounds(node.begin_keyword_loc)
+          on_kw("begin")
+        end
+
         clauses = visit_begin_node_clauses(node.begin_keyword_loc, node, false)
 
+        if node.end_keyword_loc
+          bounds(node.end_keyword_loc)
+          on_kw("end")
+        end
+
         bounds(node.location)
         on_begin(clauses)
       end
@@ -867,7 +1031,7 @@ module Prism
             on_stmts_add(on_stmts_new, on_void_stmt)
           else
             body = node.statements.body
-            body.unshift(nil) if void_stmt?(location, node.statements.body[0].location, allow_newline)
+            body = [nil, *body] if void_stmt?(location, node.statements.body[0].location, allow_newline)
 
             bounds(node.statements.location)
             visit_statements_node_body(body)
@@ -876,12 +1040,15 @@ module Prism
         rescue_clause = visit(node.rescue_clause)
         else_clause =
           unless (else_clause_node = node.else_clause).nil?
+            bounds(else_clause_node.else_keyword_loc)
+            on_kw("else")
+
             else_statements =
               if else_clause_node.statements.nil?
                 [nil]
               else
                 body = else_clause_node.statements.body
-                body.unshift(nil) if void_stmt?(else_clause_node.else_keyword_loc, else_clause_node.statements.body[0].location, allow_newline)
+                body = [nil, *body] if void_stmt?(else_clause_node.else_keyword_loc, else_clause_node.statements.body[0].location, allow_newline)
                 body
               end
 
@@ -903,7 +1070,7 @@ module Prism
           on_bodystmt(visit_statements_node_body([nil]), nil, nil, nil)
         when StatementsNode
           body = [*node.body]
-          body.unshift(nil) if void_stmt?(location, body[0].location, allow_newline)
+          body = [nil, *body] if void_stmt?(location, body[0].location, allow_newline)
           stmts = visit_statements_node_body(body)
 
           bounds(node.body.first.location)
@@ -918,6 +1085,8 @@ module Prism
       # foo(&bar)
       #     ^^^^
       def visit_block_argument_node(node)
+        bounds(node.operator_loc)
+        on_op("&")
         visit(node.expression)
       end
 
@@ -931,6 +1100,13 @@ module Prism
       # Visit a BlockNode.
       def visit_block_node(node)
         braces = node.opening == "{"
+        bounds(node.opening_loc)
+        if braces
+          on_lbrace("{")
+        else
+          on_kw("do")
+        end
+
         parameters = visit(node.parameters)
 
         body =
@@ -943,7 +1119,7 @@ module Prism
             braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
           when StatementsNode
             stmts = node.body.body
-            stmts.unshift(nil) if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
+            stmts = [nil, *stmts] if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
             stmts = visit_statements_node_body(stmts)
 
             bounds(node.body.location)
@@ -954,6 +1130,14 @@ module Prism
             raise
           end
 
+        if braces
+          bounds(node.closing_loc)
+          on_rbrace("}")
+        else
+          bounds(node.closing_loc)
+          on_kw("end")
+        end
+
         if braces
           bounds(node.location)
           on_brace_block(parameters, body)
@@ -966,12 +1150,15 @@ module Prism
       # def foo(&bar); end
       #         ^^^^
       def visit_block_parameter_node(node)
+        bounds(node.operator_loc)
+        on_op("&")
+
         if node.name_loc.nil?
           bounds(node.location)
           on_blockarg(nil)
         else
           bounds(node.name_loc)
-          name = visit_token(node.name.to_s)
+          name = on_ident(node.name.to_s)
 
           bounds(node.location)
           on_blockarg(name)
@@ -980,6 +1167,9 @@ module Prism
 
       # A block's parameters.
       def visit_block_parameters_node(node)
+        bounds(node.opening_loc)
+        on_op("|")
+
         parameters =
           if node.parameters.nil?
             on_params(nil, nil, nil, nil, nil, nil, nil)
@@ -994,6 +1184,9 @@ module Prism
             false
           end
 
+        bounds(node.closing_loc)
+        on_op("|")
+
         bounds(node.location)
         on_block_var(parameters, locals)
       end
@@ -1004,6 +1197,9 @@ module Prism
       # break foo
       # ^^^^^^^^^
       def visit_break_node(node)
+        bounds(node.keyword_loc)
+        on_kw("break")
+
         if node.arguments.nil?
           bounds(node.location)
           on_break(on_args_new)
@@ -1028,20 +1224,32 @@ module Prism
           case node.name
           when :[]
             receiver = visit(node.receiver)
-            arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+            bounds(node.opening_loc)
+            on_lbracket("[")
+
+            arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+            bounds(node.closing_loc)
+            on_rbracket("]")
+
+            block = visit(block_node)
 
             bounds(node.location)
             call = on_aref(receiver, arguments)
 
-            if block.nil?
-              call
-            else
+            if block_node
               bounds(node.location)
               on_method_add_block(call, block)
+            else
+              call
             end
           when :[]=
             receiver = visit(node.receiver)
 
+            bounds(node.opening_loc)
+            on_lbracket("[")
+
             *arguments, last_argument = node.arguments.arguments
             arguments << node.block if !node.block.nil?
 
@@ -1057,6 +1265,11 @@ module Prism
                 end
               end
 
+            bounds(node.closing_loc)
+            on_rbracket("]")
+            bounds(node.equal_loc)
+            on_op("=")
+
             bounds(node.location)
             call = on_aref_field(receiver, arguments)
             value = visit_write_value(last_argument)
@@ -1064,27 +1277,54 @@ module Prism
             bounds(last_argument.location)
             on_assign(call, value)
           when :-@, :+@, :~
-            receiver = visit(node.receiver)
+            bounds(node.message_loc)
+            on_op(node.message)
 
+            receiver = visit(node.receiver)
             bounds(node.location)
             on_unary(node.name, receiver)
           when :!
+            bounds(node.message_loc)
             if node.message == "not"
+              on_kw("not")
+
+              if node.opening_loc
+                bounds(node.opening_loc)
+                on_lparen("(")
+              end
+
               receiver =
-                if !node.receiver.is_a?(ParenthesesNode) || !node.receiver.body.nil?
+                if node.receiver.is_a?(ParenthesesNode) && node.receiver.body.nil?
+                  # The parens in `not()` just emit parens and nothing else.
+                  bounds(node.receiver.opening_loc)
+                  on_lparen("(")
+                  bounds(node.receiver.closing_loc)
+                  on_rparen(")")
+                  nil
+                else
                   visit(node.receiver)
                 end
 
+              if node.closing_loc
+                bounds(node.closing_loc)
+                on_rparen(")")
+              end
               bounds(node.location)
               on_unary(:not, receiver)
             else
+              on_op("!")
+
               receiver = visit(node.receiver)
 
               bounds(node.location)
               on_unary(:!, receiver)
             end
-          when *BINARY_OPERATORS
+          when BINARY_OPERATORS
             receiver = visit(node.receiver)
+
+            bounds(node.message_loc)
+            on_op(node.message)
+
             value = visit(node.arguments.arguments.first)
 
             bounds(node.location)
@@ -1096,9 +1336,21 @@ module Prism
             if node.variable_call?
               on_vcall(message)
             else
-              arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
+              if node.opening_loc
+                bounds(node.opening_loc)
+                on_lparen("(")
+              end
+
+              arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
+
+              if node.closing_loc
+                bounds(node.closing_loc)
+                on_rparen(")")
+              end
+
+              block = visit(block_node)
               call =
-                if node.opening_loc.nil? && arguments&.any?
+                if node.opening_loc.nil? && get_arguments_and_block(node.arguments, node.block).first.any?
                   bounds(node.location)
                   on_command(message, arguments)
                 elsif !node.opening_loc.nil?
@@ -1109,11 +1361,11 @@ module Prism
                   on_method_add_arg(on_fcall(message), on_args_new)
                 end
 
-              if block.nil?
-                call
-              else
+              if block_node
                 bounds(node.block.location)
                 on_method_add_block(call, block)
+              else
+                call
               end
             end
           end
@@ -1121,7 +1373,7 @@ module Prism
           receiver = visit(node.receiver)
 
           bounds(node.call_operator_loc)
-          call_operator = visit_token(node.call_operator)
+          call_operator = visit_call_operator(node.call_operator)
 
           message =
             if node.message_loc.nil?
@@ -1131,13 +1383,30 @@ module Prism
               visit_token(node.message, false)
             end
 
+          if node.equal_loc
+            bounds(node.equal_loc)
+            on_op("=")
+          end
+
           if node.name.end_with?("=") && !node.message.end_with?("=") && !node.arguments.nil? && node.block.nil?
             value = visit_write_value(node.arguments.arguments.first)
 
             bounds(node.location)
             on_assign(on_field(receiver, call_operator, message), value)
           else
-            arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
+            if node.opening_loc
+              bounds(node.opening_loc)
+              on_lparen("(")
+            end
+
+            arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
+
+            if node.closing_loc
+              bounds(node.closing_loc)
+              on_rparen(")")
+            end
+
+            block = visit(block_node)
             call =
               if node.opening_loc.nil?
                 bounds(node.location)
@@ -1155,27 +1424,35 @@ module Prism
                 on_method_add_arg(on_call(receiver, call_operator, message), arguments)
               end
 
-            if block.nil?
-              call
-            else
+            if block_node
               bounds(node.block.location)
               on_method_add_block(call, block)
+            else
+              call
             end
           end
         end
       end
 
-      # Visit the arguments and block of a call node and return the arguments
-      # and block as they should be used.
-      private def visit_call_node_arguments(arguments_node, block_node, trailing_comma)
+      # Extract the arguments and block Ripper-style, which means if the block
+      # is like `&b` then it's moved to arguments.
+      private def get_arguments_and_block(arguments_node, block_node)
         arguments = arguments_node&.arguments || []
         block = block_node
 
         if block.is_a?(BlockArgumentNode)
-          arguments << block
+          arguments += [block]
           block = nil
         end
 
+        [arguments, block]
+      end
+
+      # Visit the arguments and block of a call node and return the arguments
+      # and block as they should be used.
+      private def visit_call_node_arguments(arguments_node, block_node, trailing_comma)
+        arguments, block = get_arguments_and_block(arguments_node, block_node)
+
         [
           if arguments.length == 1 && arguments.first.is_a?(ForwardingArgumentsNode)
             visit(arguments.first)
@@ -1189,7 +1466,7 @@ module Prism
               on_args_add_block(args, false)
             end
           end,
-          visit(block)
+          block,
         ]
       end
 
@@ -1207,7 +1484,7 @@ module Prism
         receiver = visit(node.receiver)
 
         bounds(node.call_operator_loc)
-        call_operator = visit_token(node.call_operator)
+        call_operator = visit_call_operator(node.call_operator)
 
         bounds(node.message_loc)
         message = visit_token(node.message)
@@ -1229,7 +1506,7 @@ module Prism
         receiver = visit(node.receiver)
 
         bounds(node.call_operator_loc)
-        call_operator = visit_token(node.call_operator)
+        call_operator = visit_call_operator(node.call_operator)
 
         bounds(node.message_loc)
         message = visit_token(node.message)
@@ -1251,7 +1528,7 @@ module Prism
         receiver = visit(node.receiver)
 
         bounds(node.call_operator_loc)
-        call_operator = visit_token(node.call_operator)
+        call_operator = visit_call_operator(node.call_operator)
 
         bounds(node.message_loc)
         message = visit_token(node.message)
@@ -1273,6 +1550,9 @@ module Prism
         if node.call_operator == "::"
           receiver = visit(node.receiver)
 
+          bounds(node.call_operator_loc)
+          on_op("::")
+
           bounds(node.message_loc)
           message = visit_token(node.message)
 
@@ -1282,7 +1562,7 @@ module Prism
           receiver = visit(node.receiver)
 
           bounds(node.call_operator_loc)
-          call_operator = visit_token(node.call_operator)
+          call_operator = visit_call_operator(node.call_operator)
 
           bounds(node.message_loc)
           message = visit_token(node.message)
@@ -1296,6 +1576,10 @@ module Prism
       #        ^^^^^^^^^^
       def visit_capture_pattern_node(node)
         value = visit(node.value)
+
+        bounds(node.operator_loc)
+        on_op("=>")
+
         target = visit(node.target)
 
         bounds(node.location)
@@ -1305,10 +1589,21 @@ module Prism
       # case foo; when bar; end
       # ^^^^^^^^^^^^^^^^^^^^^^^
       def visit_case_node(node)
+        bounds(node.case_keyword_loc)
+        on_kw("case")
+
         predicate = visit(node.predicate)
+        visited_conditions = node.conditions.map { |condition| visit(condition) }
+        visited_else_clause = visit(node.else_clause)
+
+        if !node.else_clause
+          bounds(node.end_keyword_loc)
+          on_kw("end")
+        end
+
         clauses =
-          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
-            on_when(*visit(condition), current)
+          visited_conditions.reverse_each.inject(visited_else_clause) do |current, condition|
+            on_when(*condition, current)
           end
 
         bounds(node.location)
@@ -1318,10 +1613,23 @@ module Prism
       # case foo; in bar; end
       # ^^^^^^^^^^^^^^^^^^^^^
       def visit_case_match_node(node)
+        bounds(node.case_keyword_loc)
+        on_kw("case")
+
         predicate = visit(node.predicate)
+        visited_conditions = node.conditions.map do | condition|
+          visit(condition)
+        end
+        visited_else_clause = visit(node.else_clause)
+
+        if !node.else_clause
+          bounds(node.end_keyword_loc)
+          on_kw("end")
+        end
+
         clauses =
-          node.conditions.reverse_each.inject(visit(node.else_clause)) do |current, condition|
-            on_in(*visit(condition), current)
+          visited_conditions.reverse_each.inject(visited_else_clause) do |current, condition|
+            on_in(*condition, current)
           end
 
         bounds(node.location)
@@ -1331,6 +1639,9 @@ module Prism
       # class Foo; end
       # ^^^^^^^^^^^^^^
       def visit_class_node(node)
+        bounds(node.class_keyword_loc)
+        on_kw("class")
+
         constant_path =
           if node.constant_path.is_a?(ConstantReadNode)
             bounds(node.constant_path.location)
@@ -1339,9 +1650,17 @@ module Prism
             visit(node.constant_path)
           end
 
+        if node.inheritance_operator_loc
+          bounds(node.inheritance_operator_loc)
+          on_op("<")
+        end
+
         superclass = visit(node.superclass)
         bodystmt = visit_body_node(node.superclass&.location || node.constant_path.location, node.body, node.superclass.nil?)
 
+        bounds(node.end_keyword_loc)
+        on_kw("end")
+
         bounds(node.location)
         on_class(constant_path, superclass, bodystmt)
       end
@@ -1355,12 +1674,13 @@ module Prism
 
       # @@foo = 1
       # ^^^^^^^^^
-      #
-      # @@foo, @@bar = 1
-      # ^^^^^  ^^^^^
       def visit_class_variable_write_node(node)
         bounds(node.name_loc)
         target = on_var_field(on_cvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1425,12 +1745,13 @@ module Prism
 
       # Foo = 1
       # ^^^^^^^
-      #
-      # Foo, Bar = 1
-      # ^^^  ^^^
       def visit_constant_write_node(node)
         bounds(node.name_loc)
         target = on_var_field(on_const(node.name.to_s))
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1490,6 +1811,11 @@ module Prism
       # ^^^^^^^^
       def visit_constant_path_node(node)
         if node.parent.nil?
+          if node.delimiter_loc
+            bounds(node.delimiter_loc)
+            on_op("::")
+          end
+
           bounds(node.name_loc)
           child = on_const(node.name.to_s)
 
@@ -1498,6 +1824,9 @@ module Prism
         else
           parent = visit(node.parent)
 
+          bounds(node.delimiter_loc)
+          on_op("::")
+
           bounds(node.name_loc)
           child = on_const(node.name.to_s)
 
@@ -1508,11 +1837,12 @@ module Prism
 
       # Foo::Bar = 1
       # ^^^^^^^^^^^^
-      #
-      # Foo::Foo, Bar::Bar = 1
-      # ^^^^^^^^  ^^^^^^^^
       def visit_constant_path_write_node(node)
         target = visit_constant_path_write_node_target(node.target)
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1522,6 +1852,11 @@ module Prism
       # Visit a constant path that is part of a write node.
       private def visit_constant_path_write_node_target(node)
         if node.parent.nil?
+          if node.delimiter_loc
+            bounds(node.delimiter_loc)
+            on_op("::")
+          end
+
           bounds(node.name_loc)
           child = on_const(node.name.to_s)
 
@@ -1530,6 +1865,9 @@ module Prism
         else
           parent = visit(node.parent)
 
+          bounds(node.delimiter_loc)
+          on_op("::")
+
           bounds(node.name_loc)
           child = on_const(node.name.to_s)
 
@@ -1542,7 +1880,6 @@ module Prism
       # ^^^^^^^^^^^^^^^
       def visit_constant_path_operator_write_node(node)
         target = visit_constant_path_write_node_target(node.target)
-        value = visit(node.value)
 
         bounds(node.binary_operator_loc)
         operator = on_op("#{node.binary_operator}=")
@@ -1556,7 +1893,6 @@ module Prism
       # ^^^^^^^^^^^^^^^^
       def visit_constant_path_and_write_node(node)
         target = visit_constant_path_write_node_target(node.target)
-        value = visit(node.value)
 
         bounds(node.operator_loc)
         operator = on_op("&&=")
@@ -1570,7 +1906,6 @@ module Prism
       # ^^^^^^^^^^^^^^^^
       def visit_constant_path_or_write_node(node)
         target = visit_constant_path_write_node_target(node.target)
-        value = visit(node.value)
 
         bounds(node.operator_loc)
         operator = on_op("||=")
@@ -1592,16 +1927,24 @@ module Prism
       # def self.foo; end
       # ^^^^^^^^^^^^^^^^^
       def visit_def_node(node)
+        bounds(node.def_keyword_loc)
+        on_kw("def")
+
         receiver = visit(node.receiver)
         operator =
           if !node.operator_loc.nil?
             bounds(node.operator_loc)
-            visit_token(node.operator)
+            node.operator == "." ? on_period(".") : on_op("::")
           end
 
         bounds(node.name_loc)
         name = visit_token(node.name_loc.slice)
 
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
         parameters =
           if node.parameters.nil?
             bounds(node.location)
@@ -1611,10 +1954,17 @@ module Prism
           end
 
         if !node.lparen_loc.nil?
+          bounds(node.rparen_loc)
+          on_rparen(")")
           bounds(node.lparen_loc)
           parameters = on_paren(parameters)
         end
 
+        if node.equal_loc
+          bounds(node.equal_loc)
+          on_op("=")
+        end
+
         bodystmt =
           if node.equal_loc.nil?
             visit_body_node(node.rparen_loc || node.end_keyword_loc, node.body)
@@ -1625,11 +1975,16 @@ module Prism
             on_bodystmt(body, nil, nil, nil)
           end
 
+        if node.end_keyword_loc
+          bounds(node.end_keyword_loc)
+          on_kw("end")
+        end
+
         bounds(node.location)
-        if receiver.nil?
-          on_def(name, parameters, bodystmt)
-        else
+        if receiver
           on_defs(receiver, operator, name, parameters, bodystmt)
+        else
+          on_def(name, parameters, bodystmt)
         end
       end
 
@@ -1639,8 +1994,21 @@ module Prism
       # defined?(a)
       # ^^^^^^^^^^^
       def visit_defined_node(node)
+        bounds(node.keyword_loc)
+        on_kw("defined?")
+
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
         expression = visit(node.value)
 
+        if node.rparen_loc
+          bounds(node.rparen_loc)
+          on_rparen(")")
+        end
+
         # Very weird circumstances here where something like:
         #
         #     defined?
@@ -1661,17 +2029,24 @@ module Prism
       # if foo then bar else baz end
       #                 ^^^^^^^^^^^^
       def visit_else_node(node)
+        bounds(node.else_keyword_loc)
+        on_kw("else")
+
         statements =
           if node.statements.nil?
             [nil]
           else
             body = node.statements.body
-            body.unshift(nil) if void_stmt?(node.else_keyword_loc, node.statements.body[0].location, false)
+            body = [nil, *body] if void_stmt?(node.else_keyword_loc, node.statements.body[0].location, false)
             body
           end
 
+        else_statements = visit_statements_node_body(statements)
+
+        bounds(node.end_keyword_loc)
+        on_kw("end")
         bounds(node.location)
-        on_else(visit_statements_node_body(statements))
+        on_else(else_statements)
       end
 
       # "foo #{bar}"
@@ -1709,12 +2084,15 @@ module Prism
 
       # Visit an EnsureNode node.
       def visit_ensure_node(node)
+        bounds(node.ensure_keyword_loc)
+        on_kw("ensure")
+
         statements =
           if node.statements.nil?
             [nil]
           else
             body = node.statements.body
-            body.unshift(nil) if void_stmt?(node.ensure_keyword_loc, body[0].location, false)
+            body = [nil, *body] if void_stmt?(node.ensure_keyword_loc, body[0].location, false)
             body
           end
 
@@ -1735,6 +2113,14 @@ module Prism
       #        ^^^^^^^^^^^
       def visit_find_pattern_node(node)
         constant = visit(node.constant)
+
+        if node.opening_loc
+          bounds(node.opening_loc)
+          node.opening == "[" ? on_lbracket("[") : on_lparen("(")
+        end
+        bounds(node.left.operator_loc)
+        on_op("*")
+
         left =
           if node.left.expression.nil?
             bounds(node.left.location)
@@ -1744,6 +2130,10 @@ module Prism
           end
 
         requireds = visit_all(node.requireds) if node.requireds.any?
+
+        bounds(node.right.operator_loc)
+        on_op("*")
+
         right =
           if node.right.expression.nil?
             bounds(node.right.location)
@@ -1752,6 +2142,10 @@ module Prism
             visit(node.right.expression)
           end
 
+        if node.closing_loc
+          bounds(node.closing_loc)
+          node.closing == "]" ? on_rbracket("]") : on_rparen(")")
+        end
         bounds(node.location)
         on_fndptn(constant, left, requireds, right)
       end
@@ -1760,6 +2154,10 @@ module Prism
       #    ^^^^^^^^^^
       def visit_flip_flop_node(node)
         left = visit(node.left)
+
+        bounds(node.operator_loc)
+        on_op(node.operator)
+
         right = visit(node.right)
 
         bounds(node.location)
@@ -1779,8 +2177,18 @@ module Prism
       # for foo in bar do end
       # ^^^^^^^^^^^^^^^^^^^^^
       def visit_for_node(node)
+        bounds(node.for_keyword_loc)
+        on_kw("for")
+
         index = visit(node.index)
+        bounds(node.in_keyword_loc)
+        on_kw("in")
+
         collection = visit(node.collection)
+        if node.do_keyword_loc
+          bounds(node.do_keyword_loc)
+          on_kw("do")
+        end
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -1789,6 +2197,9 @@ module Prism
             visit(node.statements)
           end
 
+        bounds(node.end_keyword_loc)
+        on_kw("end")
+
         bounds(node.location)
         on_for(index, collection, statements)
       end
@@ -1797,6 +2208,7 @@ module Prism
       #                   ^^^
       def visit_forwarding_arguments_node(node)
         bounds(node.location)
+        on_op("...")
         on_args_forward
       end
 
@@ -1804,6 +2216,7 @@ module Prism
       #         ^^^
       def visit_forwarding_parameter_node(node)
         bounds(node.location)
+        on_op("...")
         on_args_forward
       end
 
@@ -1813,6 +2226,9 @@ module Prism
       # super {}
       # ^^^^^^^^
       def visit_forwarding_super_node(node)
+        bounds(node.keyword_loc)
+        on_kw("super")
+
         if node.block.nil?
           bounds(node.location)
           on_zsuper
@@ -1833,12 +2249,13 @@ module Prism
 
       # $foo = 1
       # ^^^^^^^^
-      #
-      # $foo, $bar = 1
-      # ^^^^  ^^^^
       def visit_global_variable_write_node(node)
         bounds(node.name_loc)
         target = on_var_field(on_gvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1897,6 +2314,9 @@ module Prism
       # {}
       # ^^
       def visit_hash_node(node)
+        bounds(node.opening_loc)
+        on_lbrace("{")
+
         elements =
           if node.elements.any?
             args = visit_all(node.elements)
@@ -1905,6 +2325,8 @@ module Prism
             on_assoclist_from_args(args)
           end
 
+        bounds(node.closing_loc)
+        on_rbrace("}")
         bounds(node.location)
         on_hash(elements)
       end
@@ -1913,6 +2335,15 @@ module Prism
       #        ^^
       def visit_hash_pattern_node(node)
         constant = visit(node.constant)
+
+        if node.constant
+          bounds(node.opening_loc)
+          node.opening == "[" ? on_lbracket("[") : on_lparen("(")
+        elsif node.opening_loc
+          bounds(node.opening_loc)
+          on_lbrace("{")
+        end
+
         elements =
           if node.elements.any? || !node.rest.nil?
             node.elements.map do |element|
@@ -1920,8 +2351,8 @@ module Prism
                 if (key = element.key).opening_loc.nil?
                   visit(key)
                 else
-                  bounds(key.value_loc)
-                  if (value = key.value).empty?
+                  bounds(key.content_loc)
+                  if (value = key.content).empty?
                     on_string_content
                   else
                     on_string_add(on_string_content, on_tstring_content(value))
@@ -1935,12 +2366,21 @@ module Prism
         rest =
           case node.rest
           when AssocSplatNode
+            bounds(node.rest.operator_loc)
+            on_op("**")
             visit(node.rest.value)
           when NoKeywordsParameterNode
             bounds(node.rest.location)
             on_var_field(visit(node.rest))
           end
 
+        if node.constant
+          bounds(node.closing_loc)
+          node.closing == "]" ? on_rbracket("]") : on_rparen(")")
+        elsif node.closing_loc
+          bounds(node.closing_loc)
+          on_rbrace("}")
+        end
         bounds(node.location)
         on_hshptn(constant, elements, rest)
       end
@@ -1956,13 +2396,27 @@ module Prism
       def visit_if_node(node)
         if node.then_keyword == "?"
           predicate = visit(node.predicate)
+
+          bounds(node.then_keyword_loc)
+          on_op("?")
+
           truthy = visit(node.statements.body.first)
+
+          bounds(node.subsequent.else_keyword_loc)
+          on_op(":")
+
           falsy = visit(node.subsequent.statements.body.first)
 
           bounds(node.location)
           on_ifop(predicate, truthy, falsy)
         elsif node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          bounds(node.if_keyword_loc)
+          on_kw(node.if_keyword)
           predicate = visit(node.predicate)
+          if node.then_keyword_loc && node.then_keyword != "?"
+            bounds(node.then_keyword_loc)
+            on_kw("then")
+          end
           statements =
             if node.statements.nil?
               bounds(node.location)
@@ -1972,6 +2426,11 @@ module Prism
             end
           subsequent = visit(node.subsequent)
 
+          if node.end_keyword_loc && !node.subsequent
+            bounds(node.end_keyword_loc)
+            on_kw("end")
+          end
+
           bounds(node.location)
           if node.if_keyword == "if"
             on_if(predicate, statements, subsequent)
@@ -1980,6 +2439,8 @@ module Prism
           end
         else
           statements = visit(node.statements.body.first)
+          bounds(node.if_keyword_loc)
+          on_kw(node.if_keyword)
           predicate = visit(node.predicate)
 
           bounds(node.location)
@@ -2011,7 +2472,14 @@ module Prism
         # 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_keyword_loc)
+        on_kw("in")
+
         pattern = visit_pattern_node(node.pattern)
+        if node.then_keyword_loc
+          bounds(node.then_keyword_loc)
+          on_kw("then")
+        end
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -2027,8 +2495,15 @@ module Prism
       # ^^^^^^^^^^^^^^^
       def visit_index_operator_write_node(node)
         receiver = visit(node.receiver)
+
+        bounds(node.opening_loc)
+        on_lbracket("[")
+
         arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
 
+        bounds(node.closing_loc)
+        on_rbracket("]")
+
         bounds(node.location)
         target = on_aref_field(receiver, arguments)
 
@@ -2044,8 +2519,15 @@ module Prism
       # ^^^^^^^^^^^^^^^^
       def visit_index_and_write_node(node)
         receiver = visit(node.receiver)
+
+        bounds(node.opening_loc)
+        on_lbracket("[")
+
         arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
 
+        bounds(node.closing_loc)
+        on_rbracket("]")
+
         bounds(node.location)
         target = on_aref_field(receiver, arguments)
 
@@ -2061,8 +2543,15 @@ module Prism
       # ^^^^^^^^^^^^^^^^
       def visit_index_or_write_node(node)
         receiver = visit(node.receiver)
+
+        bounds(node.opening_loc)
+        on_lbracket("[")
+
         arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
 
+        bounds(node.closing_loc)
+        on_rbracket("]")
+
         bounds(node.location)
         target = on_aref_field(receiver, arguments)
 
@@ -2078,8 +2567,15 @@ module Prism
       # ^^^^^^^^
       def visit_index_target_node(node)
         receiver = visit(node.receiver)
+
+        bounds(node.opening_loc)
+        on_lbracket("[")
+
         arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
 
+        bounds(node.closing_loc)
+        on_rbracket("]")
+
         bounds(node.location)
         on_aref_field(receiver, arguments)
       end
@@ -2096,6 +2592,10 @@ module Prism
       def visit_instance_variable_write_node(node)
         bounds(node.name_loc)
         target = on_var_field(on_ivar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -2198,20 +2698,37 @@ module Prism
       # "foo #{bar}"
       # ^^^^^^^^^^^^
       def visit_interpolated_string_node(node)
-        if node.opening&.start_with?("<<~")
-          heredoc = visit_heredoc_string_node(node)
+        with_string_bounds(node) do
+          if node.opening&.start_with?("<<~")
+            heredoc = visit_heredoc_string_node(node)
 
-          bounds(node.location)
-          on_string_literal(heredoc)
-        elsif !node.heredoc? && node.parts.length > 1 && node.parts.any? { |part| (part.is_a?(StringNode) || part.is_a?(InterpolatedStringNode)) && !part.opening_loc.nil? }
-          first, *rest = node.parts
-          rest.inject(visit(first)) do |content, part|
-            concat = visit(part)
+            bounds(node.location)
+            on_string_literal(heredoc)
+          elsif !node.heredoc? && node.parts.length > 1 && node.parts.any? { |part| (part.is_a?(StringNode) || part.is_a?(InterpolatedStringNode)) && !part.opening_loc.nil? }
+            first, *rest = node.parts
+            rest.inject(visit(first)) do |content, part|
+              concat = visit(part)
+
+              bounds(part.location)
+              on_string_concat(content, concat)
+            end
+          else
+            bounds(node.parts.first.location)
+            parts =
+              node.parts.inject(on_string_content) do |content, part|
+                on_string_add(content, visit_string_content(part))
+              end
 
-            bounds(part.location)
-            on_string_concat(content, concat)
+            bounds(node.location)
+            on_string_literal(parts)
           end
-        else
+        end
+      end
+
+      # :"foo #{bar}"
+      # ^^^^^^^^^^^^^
+      def visit_interpolated_symbol_node(node)
+        with_string_bounds(node) do
           bounds(node.parts.first.location)
           parts =
             node.parts.inject(on_string_content) do |content, part|
@@ -2219,40 +2736,29 @@ module Prism
             end
 
           bounds(node.location)
-          on_string_literal(parts)
+          on_dyna_symbol(parts)
         end
       end
 
-      # :"foo #{bar}"
-      # ^^^^^^^^^^^^^
-      def visit_interpolated_symbol_node(node)
-        bounds(node.parts.first.location)
-        parts =
-          node.parts.inject(on_string_content) do |content, part|
-            on_string_add(content, visit_string_content(part))
-          end
-
-        bounds(node.location)
-        on_dyna_symbol(parts)
-      end
-
       # `foo #{bar}`
       # ^^^^^^^^^^^^
       def visit_interpolated_x_string_node(node)
-        if node.opening.start_with?("<<~")
-          heredoc = visit_heredoc_x_string_node(node)
+        with_string_bounds(node) do
+          if node.opening.start_with?("<<~")
+            heredoc = visit_heredoc_x_string_node(node)
 
-          bounds(node.location)
-          on_xstring_literal(heredoc)
-        else
-          bounds(node.parts.first.location)
-          parts =
-            node.parts.inject(on_xstring_new) do |content, part|
-              on_xstring_add(content, visit_string_content(part))
-            end
+            bounds(node.location)
+            on_xstring_literal(heredoc)
+          else
+            bounds(node.parts.first.location)
+            parts =
+              node.parts.inject(on_xstring_new) do |content, part|
+                on_xstring_add(content, visit_string_content(part))
+              end
 
-          bounds(node.location)
-          on_xstring_literal(parts)
+            bounds(node.location)
+            on_xstring_literal(parts)
+          end
         end
       end
 
@@ -2293,6 +2799,9 @@ module Prism
       # def foo(**); end
       #         ^^
       def visit_keyword_rest_parameter_node(node)
+        bounds(node.operator_loc)
+        on_op("**")
+
         if node.name_loc.nil?
           bounds(node.location)
           on_kwrest_param(nil)
@@ -2312,6 +2821,11 @@ module Prism
 
         parameters =
           if node.parameters.is_a?(BlockParametersNode)
+            if node.parameters.opening_loc
+              bounds(node.parameters.opening_loc)
+              on_lparen("(")
+            end
+
             # Ripper does not track block-locals within lambdas, so we skip
             # directly to the parameters here.
             params =
@@ -2322,6 +2836,13 @@ module Prism
                 visit(node.parameters.parameters)
               end
 
+            visit_all(node.parameters.locals)
+
+            if node.parameters.closing_loc
+              bounds(node.parameters.closing_loc)
+              on_rparen(")")
+            end
+
             if node.parameters.opening_loc.nil?
               params
             else
@@ -2334,9 +2855,11 @@ module Prism
           end
 
         braces = node.opening == "{"
+        bounds(node.opening_loc)
         if braces
-          bounds(node.opening_loc)
           on_tlambeg(node.opening)
+        else
+          on_kw("do")
         end
 
         body =
@@ -2349,7 +2872,7 @@ module Prism
             braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
           when StatementsNode
             stmts = node.body.body
-            stmts.unshift(nil) if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
+            stmts = [nil, *stmts] if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
             stmts = visit_statements_node_body(stmts)
 
             bounds(node.body.location)
@@ -2360,6 +2883,13 @@ module Prism
             raise
           end
 
+          bounds(node.closing_loc)
+        if braces
+          on_rbrace("}")
+        else
+          on_kw("end")
+        end
+
         bounds(node.location)
         on_lambda(parameters, body)
       end
@@ -2376,6 +2906,10 @@ module Prism
       def visit_local_variable_write_node(node)
         bounds(node.name_loc)
         target = on_var_field(on_ident(node.name_loc.slice))
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -2450,6 +2984,8 @@ module Prism
       # ^^^^^^^^^^
       def visit_match_predicate_node(node)
         value = visit(node.value)
+        bounds(node.keyword_loc)
+        on_kw("in")
         pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
 
         on_case(value, pattern)
@@ -2459,6 +2995,10 @@ module Prism
       # ^^^^^^^^^^
       def visit_match_required_node(node)
         value = visit(node.value)
+
+        bounds(node.operator_loc)
+        on_op("=>")
+
         pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
 
         on_case(value, pattern)
@@ -2472,13 +3012,16 @@ module Prism
 
       # A node that is missing from the syntax tree. This is only used in the
       # case of a syntax error.
-      def visit_missing_node(node)
-        raise "Cannot visit missing nodes directly."
+      def visit_error_recovery_node(node)
+        raise "Cannot visit error recovery nodes directly."
       end
 
       # module Foo; end
       # ^^^^^^^^^^^^^^^
       def visit_module_node(node)
+        bounds(node.module_keyword_loc)
+        on_kw("module")
+
         constant_path =
           if node.constant_path.is_a?(ConstantReadNode)
             bounds(node.constant_path.location)
@@ -2489,6 +3032,9 @@ module Prism
 
         bodystmt = visit_body_node(node.constant_path.location, node.body, true)
 
+        bounds(node.end_keyword_loc)
+        on_kw("end")
+
         bounds(node.location)
         on_module(constant_path, bodystmt)
       end
@@ -2496,9 +3042,19 @@ module Prism
       # (foo, bar), bar = qux
       # ^^^^^^^^^^
       def visit_multi_target_node(node)
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
         bounds(node.location)
         targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)
 
+        if node.rparen_loc
+          bounds(node.rparen_loc)
+          on_rparen(")")
+        end
+
         if node.lparen_loc.nil?
           targets
         else
@@ -2550,9 +3106,22 @@ module Prism
       # foo, bar = baz
       # ^^^^^^^^^^^^^^
       def visit_multi_write_node(node)
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
         bounds(node.location)
         targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)
 
+        if node.rparen_loc
+          bounds(node.rparen_loc)
+          on_rparen(")")
+        end
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         unless node.lparen_loc.nil?
           bounds(node.lparen_loc)
           targets = on_mlhs_paren(targets)
@@ -2570,6 +3139,9 @@ module Prism
       # next foo
       # ^^^^^^^^
       def visit_next_node(node)
+        bounds(node.keyword_loc)
+        on_kw("next")
+
         if node.arguments.nil?
           bounds(node.location)
           on_next(on_args_new)
@@ -2588,9 +3160,24 @@ module Prism
         on_var_ref(on_kw("nil"))
       end
 
+      # def foo(&nil); end
+      #         ^^^^
+      def visit_no_block_parameter_node(node)
+        bounds(node.operator_loc)
+        on_op("&")
+        bounds(node.keyword_loc)
+        on_kw("nil")
+        bounds(node.location)
+        on_blockarg(:nil)
+      end
+
       # def foo(**nil); end
       #         ^^^^^
       def visit_no_keywords_parameter_node(node)
+        bounds(node.operator_loc)
+        on_op("**")
+        bounds(node.keyword_loc)
+        on_kw("nil")
         bounds(node.location)
         on_nokw_param(nil)
 
@@ -2623,7 +3210,11 @@ module Prism
       #         ^^^^^^^
       def visit_optional_parameter_node(node)
         bounds(node.name_loc)
-        name = visit_token(node.name.to_s)
+        name = on_ident(node.name.to_s)
+
+        bounds(node.operator_loc)
+        on_op("=")
+
         value = visit(node.value)
 
         [name, value]
@@ -2633,6 +3224,14 @@ module Prism
       # ^^^^^^
       def visit_or_node(node)
         left = visit(node.left)
+
+        bounds(node.operator_loc)
+        if node.operator == "or"
+          on_kw("or")
+        else
+          on_op("||")
+        end
+
         right = visit(node.right)
 
         bounds(node.location)
@@ -2656,9 +3255,19 @@ module Prism
 
       # Visit a destructured positional parameter node.
       private def visit_destructured_parameter_node(node)
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
         bounds(node.location)
         targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, false)
 
+        if node.rparen_loc
+          bounds(node.rparen_loc)
+          on_rparen(")")
+        end
+
         bounds(node.lparen_loc)
         on_mlhs_paren(targets)
       end
@@ -2669,6 +3278,9 @@ module Prism
       # (1)
       # ^^^
       def visit_parentheses_node(node)
+        bounds(node.opening_loc)
+        on_lparen("(")
+
         body =
           if node.body.nil?
             on_stmts_add(on_stmts_new, on_void_stmt)
@@ -2676,6 +3288,8 @@ module Prism
             visit(node.body)
           end
 
+        bounds(node.closing_loc)
+        on_rparen(")")
         bounds(node.location)
         on_paren(body)
       end
@@ -2683,8 +3297,15 @@ module Prism
       # foo => ^(bar)
       #        ^^^^^^
       def visit_pinned_expression_node(node)
+        bounds(node.operator_loc)
+        on_op("^")
+        bounds(node.lparen_loc)
+        on_lparen("(")
+
         expression = visit(node.expression)
 
+        bounds(node.rparen_loc)
+        on_rparen(")")
         bounds(node.location)
         on_begin(expression)
       end
@@ -2692,12 +3313,20 @@ module Prism
       # foo = 1 and bar => ^foo
       #                    ^^^^
       def visit_pinned_variable_node(node)
+        bounds(node.operator_loc)
+        on_op("^")
+
         visit(node.variable)
       end
 
       # END {}
       # ^^^^^^
       def visit_post_execution_node(node)
+        bounds(node.keyword_loc)
+        on_kw("END")
+        bounds(node.opening_loc)
+        on_lbrace("{")
+
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -2706,6 +3335,8 @@ module Prism
             visit(node.statements)
           end
 
+        bounds(node.closing_loc)
+        on_rbrace("}")
         bounds(node.location)
         on_END(statements)
       end
@@ -2713,6 +3344,11 @@ module Prism
       # BEGIN {}
       # ^^^^^^^^
       def visit_pre_execution_node(node)
+        bounds(node.keyword_loc)
+        on_kw("BEGIN")
+        bounds(node.opening_loc)
+        on_lbrace("{")
+
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -2721,6 +3357,8 @@ module Prism
             visit(node.statements)
           end
 
+        bounds(node.closing_loc)
+        on_rbrace("}")
         bounds(node.location)
         on_BEGIN(statements)
       end
@@ -2728,7 +3366,7 @@ module Prism
       # The top-level program node.
       def visit_program_node(node)
         body = node.statements.body
-        body << nil if body.empty?
+        body = [nil] if body.empty?
         statements = visit_statements_node_body(body)
 
         bounds(node.location)
@@ -2739,6 +3377,10 @@ module Prism
       # ^^^^
       def visit_range_node(node)
         left = visit(node.left)
+
+        bounds(node.operator_loc)
+        on_op(node.operator)
+
         right = visit(node.right)
 
         bounds(node.location)
@@ -2759,6 +3401,7 @@ module Prism
       # ^^^^
       def visit_redo_node(node)
         bounds(node.location)
+        on_kw("redo")
         on_redo
       end
 
@@ -2801,6 +3444,9 @@ module Prism
       # foo rescue bar
       # ^^^^^^^^^^^^^^
       def visit_rescue_modifier_node(node)
+        bounds(node.keyword_loc)
+        on_kw("rescue")
+
         expression = visit_write_value(node.expression)
         rescue_expression = visit(node.rescue_expression)
 
@@ -2811,6 +3457,9 @@ module Prism
       # begin; rescue; end
       #        ^^^^^^^
       def visit_rescue_node(node)
+        bounds(node.keyword_loc)
+        on_kw("rescue")
+
         exceptions =
           case node.exceptions.length
           when 0
@@ -2848,6 +3497,11 @@ module Prism
             end
           end
 
+        if node.operator_loc
+          bounds(node.operator_loc)
+          on_op("=>")
+        end
+
         reference = visit(node.reference)
         statements =
           if node.statements.nil?
@@ -2869,12 +3523,15 @@ module Prism
       # def foo(*); end
       #         ^
       def visit_rest_parameter_node(node)
+        bounds(node.operator_loc)
+        on_op("*")
+
         if node.name_loc.nil?
           bounds(node.location)
           on_rest_param(nil)
         else
           bounds(node.name_loc)
-          on_rest_param(visit_token(node.name.to_s))
+          on_rest_param(on_ident(node.name.to_s))
         end
       end
 
@@ -2882,6 +3539,7 @@ module Prism
       # ^^^^^
       def visit_retry_node(node)
         bounds(node.location)
+        on_kw("retry")
         on_retry
       end
 
@@ -2891,6 +3549,9 @@ module Prism
       # return 1
       # ^^^^^^^^
       def visit_return_node(node)
+        bounds(node.keyword_loc)
+        on_kw("return")
+
         if node.arguments.nil?
           bounds(node.location)
           on_return0
@@ -2917,9 +3578,17 @@ module Prism
       # class << self; end
       # ^^^^^^^^^^^^^^^^^^
       def visit_singleton_class_node(node)
+        bounds(node.class_keyword_loc)
+        on_kw("class")
+        bounds(node.operator_loc)
+        on_op("<<")
+
         expression = visit(node.expression)
         bodystmt = visit_body_node(node.body&.location || node.end_keyword_loc, node.body)
 
+        bounds(node.end_keyword_loc)
+        on_kw("end")
+
         bounds(node.location)
         on_sclass(expression, bodystmt)
       end
@@ -2954,6 +3623,8 @@ module Prism
       # def foo(*); bar(*); end
       #                 ^
       def visit_splat_node(node)
+        bounds(node.operator_loc)
+        on_op("*")
         visit(node.expression)
       end
 
@@ -2976,24 +3647,66 @@ module Prism
       # "foo"
       # ^^^^^
       def visit_string_node(node)
-        if (content = node.content).empty?
-          bounds(node.location)
-          on_string_literal(on_string_content)
-        elsif (opening = node.opening) == "?"
-          bounds(node.location)
-          on_CHAR("?#{node.content}")
-        elsif opening.start_with?("<<~")
-          heredoc = visit_heredoc_string_node(node.to_interpolated)
+        with_string_bounds(node) do
+          if (content = node.content).empty?
+            bounds(node.location)
+            on_string_literal(on_string_content)
+          elsif (opening = node.opening) == "?"
+            bounds(node.location)
+            on_CHAR("?#{node.content}")
+          elsif opening.start_with?("<<~")
+            heredoc = visit_heredoc_string_node(node.to_interpolated)
 
-          bounds(node.location)
-          on_string_literal(heredoc)
-        else
-          bounds(node.content_loc)
-          tstring_content = on_tstring_content(content)
+            bounds(node.location)
+            on_string_literal(heredoc)
+          else
+            bounds(node.content_loc)
+            tstring_content = on_tstring_content(content)
 
-          bounds(node.location)
-          on_string_literal(on_string_add(on_string_content, tstring_content))
+            bounds(node.location)
+            on_string_literal(on_string_add(on_string_content, tstring_content))
+          end
+        end
+      end
+
+      # Responsible for emitting the various string-like begin/end events
+      private def with_string_bounds(node)
+        # `foo "bar": baz` doesn't emit the closing location
+        assoc = !(opening = node.opening)&.include?(":") && node.closing&.end_with?(":")
+
+        is_heredoc = opening&.start_with?("<<")
+        if is_heredoc
+          bounds(node.opening_loc)
+          on_heredoc_beg(node.opening)
+        elsif opening&.start_with?(":", "%s")
+          bounds(node.opening_loc)
+          on_symbeg(node.opening)
+        elsif opening&.start_with?("`", "%x")
+          bounds(node.opening_loc)
+          on_backtick(node.opening)
+        elsif opening && !opening.start_with?("?")
+          bounds(node.opening_loc)
+          on_tstring_beg(opening)
+        end
+
+        result = yield
+        if assoc
+          if node.closing != ":"
+            bounds(node.closing_loc)
+            on_label_end(node.closing)
+          end
+          return result
         end
+
+        if is_heredoc
+          bounds(node.closing_loc)
+          on_heredoc_end(node.closing)
+        elsif node.closing_loc
+          bounds(node.closing_loc)
+          on_tstring_end(node.closing)
+        end
+
+        result
       end
 
       # Ripper gives back the escaped string content but strips out the common
@@ -3073,42 +3786,39 @@ module Prism
 
       # Visit a heredoc node that is representing a string.
       private def visit_heredoc_string_node(node)
-        bounds(node.opening_loc)
-        on_heredoc_beg(node.opening)
-
         bounds(node.location)
-        result =
-          visit_heredoc_node(node.parts, on_string_content) do |parts, part|
-            on_string_add(parts, part)
-          end
-
-        bounds(node.closing_loc)
-        on_heredoc_end(node.closing)
-
-        result
+        visit_heredoc_node(node.parts, on_string_content) do |parts, part|
+          on_string_add(parts, part)
+        end
       end
 
       # Visit a heredoc node that is representing an xstring.
       private def visit_heredoc_x_string_node(node)
-        bounds(node.opening_loc)
-        on_heredoc_beg(node.opening)
-
         bounds(node.location)
-        result =
-          visit_heredoc_node(node.parts, on_xstring_new) do |parts, part|
-            on_xstring_add(parts, part)
-          end
-
-        bounds(node.closing_loc)
-        on_heredoc_end(node.closing)
-
-        result
+        visit_heredoc_node(node.parts, on_xstring_new) do |parts, part|
+          on_xstring_add(parts, part)
+        end
       end
 
       # super(foo)
       # ^^^^^^^^^^
       def visit_super_node(node)
-        arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.rparen_loc || node.location))
+        bounds(node.keyword_loc)
+        on_kw("super")
+
+        if node.lparen_loc
+          bounds(node.lparen_loc)
+          on_lparen("(")
+        end
+
+        arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.rparen_loc || node.location))
+
+        if node.rparen_loc
+          bounds(node.rparen_loc)
+          on_rparen(")")
+        end
+
+        block = visit(block_node)
 
         if !node.lparen_loc.nil?
           bounds(node.lparen_loc)
@@ -3118,35 +3828,38 @@ module Prism
         bounds(node.location)
         call = on_super(arguments)
 
-        if block.nil?
-          call
-        else
+        if block_node
           bounds(node.block.location)
           on_method_add_block(call, block)
+        else
+          call
         end
       end
 
       # :foo
       # ^^^^
       def visit_symbol_node(node)
-        if (opening = node.opening)&.match?(/^%s|['"]:?$/)
-          bounds(node.value_loc)
-          content = on_string_content
+        with_string_bounds(node) do
+          if (opening = node.opening)&.match?(/^%s|['"]:?$/)
+            bounds(node.content_loc)
+            content = on_string_content
 
-          if !(value = node.value).empty?
-            content = on_string_add(content, on_tstring_content(value))
-          end
+            if !(value = node.content).empty?
+              content = on_string_add(content, on_tstring_content(value))
+            end
 
-          on_dyna_symbol(content)
-        elsif (closing = node.closing) == ":"
-          bounds(node.location)
-          on_label("#{node.value}:")
-        elsif opening.nil? && node.closing_loc.nil?
-          bounds(node.value_loc)
-          on_symbol_literal(visit_token(node.value))
-        else
-          bounds(node.value_loc)
-          on_symbol_literal(on_symbol(visit_token(node.value)))
+            bounds(node.location)
+            on_dyna_symbol(content)
+          elsif (closing = node.closing) == ":"
+            bounds(node.location)
+            on_label("#{node.content}:")
+          elsif opening.nil? && node.closing_loc.nil?
+            bounds(node.content_loc)
+            on_symbol_literal(visit_token(node.content))
+          else
+            bounds(node.content_loc)
+            on_symbol_literal(on_symbol(visit_token(node.content)))
+          end
         end
       end
 
@@ -3160,6 +3873,9 @@ module Prism
       # undef foo
       # ^^^^^^^^^
       def visit_undef_node(node)
+        bounds(node.keyword_loc)
+        on_kw("undef")
+
         names = visit_all(node.names)
 
         bounds(node.location)
@@ -3173,7 +3889,13 @@ module Prism
       # ^^^^^^^^^^^^^^
       def visit_unless_node(node)
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          bounds(node.unless_keyword_loc)
+          on_kw("unless")
           predicate = visit(node.predicate)
+          if node.then_keyword_loc
+            bounds(node.then_keyword_loc)
+            on_kw("then")
+          end
           statements =
             if node.statements.nil?
               bounds(node.location)
@@ -3183,10 +3905,17 @@ module Prism
             end
           else_clause = visit(node.else_clause)
 
+          if node.end_keyword_loc && !node.else_clause
+            bounds(node.end_keyword_loc)
+            on_kw("end")
+          end
+
           bounds(node.location)
           on_unless(predicate, statements, else_clause)
         else
           statements = visit(node.statements.body.first)
+          bounds(node.unless_keyword_loc)
+          on_kw("unless")
           predicate = visit(node.predicate)
 
           bounds(node.location)
@@ -3200,7 +3929,14 @@ module Prism
       # bar until foo
       # ^^^^^^^^^^^^^
       def visit_until_node(node)
+        bounds(node.until_keyword_loc)
+        on_kw("until")
+
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          if node.do_keyword_loc
+            bounds(node.do_keyword_loc)
+            on_kw("do")
+          end
           predicate = visit(node.predicate)
           statements =
             if node.statements.nil?
@@ -3210,6 +3946,11 @@ module Prism
               visit(node.statements)
             end
 
+          if node.end_keyword_loc
+            bounds(node.end_keyword_loc)
+            on_kw("end")
+          end
+
           bounds(node.location)
           on_until(predicate, statements)
         else
@@ -3227,7 +3968,14 @@ module Prism
         # 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.when_keyword_loc)
+        on_kw("when")
+
         conditions = visit_arguments(node.conditions)
+        if node.then_keyword_loc
+          bounds(node.then_keyword_loc)
+          on_kw("then")
+        end
         statements =
           if node.statements.nil?
             bounds(node.location)
@@ -3246,7 +3994,17 @@ module Prism
       # ^^^^^^^^^^^^^
       def visit_while_node(node)
         if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          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.end_keyword_loc
+            bounds(node.end_keyword_loc)
+            on_kw("end")
+          end
           statements =
             if node.statements.nil?
               bounds(node.location)
@@ -3259,6 +4017,8 @@ module Prism
           on_while(predicate, statements)
         else
           statements = visit(node.statements.body.first)
+          bounds(node.while_keyword_loc)
+          on_kw("while")
           predicate = visit(node.predicate)
 
           bounds(node.location)
@@ -3269,20 +4029,22 @@ module Prism
       # `foo`
       # ^^^^^
       def visit_x_string_node(node)
-        if node.unescaped.empty?
-          bounds(node.location)
-          on_xstring_literal(on_xstring_new)
-        elsif node.opening.start_with?("<<~")
-          heredoc = visit_heredoc_x_string_node(node.to_interpolated)
+        with_string_bounds(node) do
+          if node.unescaped.empty?
+            bounds(node.location)
+            on_xstring_literal(on_xstring_new)
+          elsif node.opening.start_with?("<<~")
+            heredoc = visit_heredoc_x_string_node(node.to_interpolated)
 
-          bounds(node.location)
-          on_xstring_literal(heredoc)
-        else
-          bounds(node.content_loc)
-          content = on_tstring_content(node.content)
+            bounds(node.location)
+            on_xstring_literal(heredoc)
+          else
+            bounds(node.content_loc)
+            content = on_tstring_content(node.content)
 
-          bounds(node.location)
-          on_xstring_literal(on_xstring_add(on_xstring_new, content))
+            bounds(node.location)
+            on_xstring_literal(on_xstring_add(on_xstring_new, content))
+          end
         end
       end
 
@@ -3292,10 +4054,18 @@ module Prism
       # yield 1
       # ^^^^^^^
       def visit_yield_node(node)
+        bounds(node.keyword_loc)
+        on_kw("yield")
+
         if node.arguments.nil? && node.lparen_loc.nil?
           bounds(node.location)
           on_yield0
         else
+          if node.lparen_loc
+            bounds(node.lparen_loc)
+            on_lparen("(")
+          end
+
           arguments =
             if node.arguments.nil?
               bounds(node.location)
@@ -3305,6 +4075,8 @@ module Prism
             end
 
           unless node.lparen_loc.nil?
+            bounds(node.rparen_loc)
+            on_rparen(")")
             bounds(node.lparen_loc)
             arguments = on_paren(arguments)
           end
@@ -3318,7 +4090,11 @@ module Prism
 
       # Lazily initialize the parse result.
       def result
-        @result ||= Prism.parse(source, partial_script: true, version: "current")
+        @result ||= Prism.parse(source, partial_script: true, version: "current", freeze: true, encoding: source.encoding)
+      end
+
+      def line_and_column_cache
+        @line_and_column_cache ||= LineAndColumnCache.new(result.source)
       end
 
       ##########################################################################
@@ -3339,30 +4115,34 @@ module Prism
       # Visit the string content of a particular node. This method is used to
       # split into the various token types.
       def visit_token(token, allow_keywords = true)
-        case token
-        when "."
+        if token == "."
           on_period(token)
-        when "`"
+        elsif token == "`"
           on_backtick(token)
-        when *(allow_keywords ? KEYWORDS : [])
+        elsif allow_keywords && KEYWORDS.include?(token)
           on_kw(token)
-        when /^_/
+        elsif token.start_with?("_")
           on_ident(token)
-        when /^[[:upper:]]\w*$/
+        elsif token.match?(/^[[:upper:]]\w*$/)
           on_const(token)
-        when /^@@/
+        elsif token.start_with?("@@")
           on_cvar(token)
-        when /^@/
+        elsif token.start_with?("@")
           on_ivar(token)
-        when /^\$/
+        elsif token.start_with?("$")
           on_gvar(token)
-        when /^[[:punct:]]/
+        elsif token.match?(/^[[:punct:]]/)
           on_op(token)
         else
           on_ident(token)
         end
       end
 
+      # Visit either `.`, `&.`, or `::`.
+      def visit_call_operator(token)
+        token == "." ? on_period(token) : on_op(token)
+      end
+
       # Visit a node that represents a number. We need to explicitly handle the
       # unary - operator.
       def visit_number_node(node)
@@ -3370,6 +4150,9 @@ module Prism
         location = node.location
 
         if slice[0] == "-"
+          bounds(location.copy(length: 1))
+          on_op("-")
+
           bounds(location.copy(start_offset: location.start_offset + 1))
           value = yield slice[1..-1]
 
@@ -3418,26 +4201,24 @@ module Prism
 
       # This method is responsible for updating lineno and column information
       # to reflect the current node.
-      #
-      # This method could be drastically improved with some caching on the start
-      # of every line, but for now it's good enough.
       def bounds(location)
-        @lineno = location.start_line
-        @column = location.start_column
+        @lineno, @column = line_and_column_cache.line_and_column(location.start_offset)
       end
 
+      # :startdoc:
+
       ##########################################################################
       # Ripper interface
       ##########################################################################
 
       # :stopdoc:
       def _dispatch_0; end
-      def _dispatch_1(_); end
-      def _dispatch_2(_, _); end
-      def _dispatch_3(_, _, _); end
-      def _dispatch_4(_, _, _, _); end
-      def _dispatch_5(_, _, _, _, _); end
-      def _dispatch_7(_, _, _, _, _, _, _); end
+      def _dispatch_1(arg); arg end
+      def _dispatch_2(arg, _); arg end
+      def _dispatch_3(arg, _, _); arg end
+      def _dispatch_4(arg, _, _, _); arg end
+      def _dispatch_5(arg, _, _, _, _); arg end
+      def _dispatch_7(arg, _, _, _, _, _, _); arg end
       # :startdoc:
 
       #