prism 0.24.0 → 0.25.0

data/lib/prism/translation/ripper.rb

@@ -4,67 +4,436 @@ require "ripper"
 
 module Prism
   module Translation
-    # Note: This integration is not finished, and therefore still has many
-    # inconsistencies with Ripper. If you'd like to help out, pull requests would
-    # be greatly appreciated!
+    # This class provides a compatibility layer between prism and Ripper. It
+    # functions by parsing the entire tree first and then walking it and
+    # executing each of the Ripper callbacks as it goes. To use this class, you
+    # treat `Prism::Translation::Ripper` effectively as you would treat the
+    # `Ripper` class.
     #
-    # This class is meant to provide a compatibility layer between prism and
-    # Ripper. It functions by parsing the entire tree first and then walking it
-    # and executing each of the Ripper callbacks as it goes.
+    # Note that this class will serve the most common use cases, but Ripper's
+    # API is extensive and undocumented. It relies on reporting the state of the
+    # parser at any given time. We do our best to replicate that here, but
+    # because it is a different architecture it is not possible to perfectly
+    # replicate the behavior of Ripper.
     #
-    # This class is going to necessarily be slower than the native Ripper API. It
-    # is meant as a stopgap until developers migrate to using prism. It is also
-    # meant as a test harness for the prism parser.
+    # The main known difference is that we may omit dispatching some events in
+    # some cases. This impacts the following events:
+    #
+    # * on_assign_error
+    # * 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
     #
-    # To use this class, you treat `Prism::Translation::Ripper` effectively as you would
-    # treat the `Ripper` class.
     class Ripper < Compiler
-      # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that
-      # returns the arrays of [type, *children].
-      class SexpBuilder < Ripper
-        private
+      # Parses the given Ruby program read from +src+.
+      # +src+ must be a String or an IO or a object with a #gets method.
+      def Ripper.parse(src, filename = "(ripper)", lineno = 1)
+        new(src, filename, lineno).parse
+      end
 
-        ::Ripper::PARSER_EVENTS.each do |event|
-          define_method(:"on_#{event}") do |*args|
-            [event, *args]
-          end
-        end
+      # Tokenizes the Ruby program and returns an array of an array,
+      # which is formatted like
+      # <code>[[lineno, column], type, token, state]</code>.
+      # The +filename+ argument is mostly ignored.
+      # 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+.
+      #
+      #   require 'ripper'
+      #   require 'pp'
+      #
+      #   pp Ripper.lex("def m(a) nil end")
+      #   #=> [[[1,  0], :on_kw,     "def", FNAME    ],
+      #        [[1,  3], :on_sp,     " ",   FNAME    ],
+      #        [[1,  4], :on_ident,  "m",   ENDFN    ],
+      #        [[1,  5], :on_lparen, "(",   BEG|LABEL],
+      #        [[1,  6], :on_ident,  "a",   ARG      ],
+      #        [[1,  7], :on_rparen, ")",   ENDFN    ],
+      #        [[1,  8], :on_sp,     " ",   BEG      ],
+      #        [[1,  9], :on_kw,     "nil", END      ],
+      #        [[1, 12], :on_sp,     " ",   END      ],
+      #        [[1, 13], :on_kw,     "end", END      ]]
+      #
+      def Ripper.lex(src, filename = "-", lineno = 1, raise_errors: false)
+        result = Prism.lex_compat(src, filepath: filename, line: lineno)
 
-        ::Ripper::SCANNER_EVENTS.each do |event|
-          define_method(:"on_#{event}") do |value|
-            [:"@#{event}", value, [lineno, column]]
-          end
+        if result.failure? && raise_errors
+          raise SyntaxError, result.errors.first.message
+        else
+          result.value
         end
       end
 
-      # This class mirrors the ::Ripper::SexpBuilderPP subclass of ::Ripper that
-      # returns the same values as ::Ripper::SexpBuilder except with a couple of
-      # niceties that flatten linked lists into arrays.
-      class SexpBuilderPP < SexpBuilder
-        private
+      # This contains a table of all of the parser events and their
+      # corresponding arity.
+      PARSER_EVENT_TABLE = {
+        BEGIN: 1,
+        END: 1,
+        alias: 2,
+        alias_error: 2,
+        aref: 2,
+        aref_field: 2,
+        arg_ambiguous: 1,
+        arg_paren: 1,
+        args_add: 2,
+        args_add_block: 2,
+        args_add_star: 2,
+        args_forward: 0,
+        args_new: 0,
+        array: 1,
+        aryptn: 4,
+        assign: 2,
+        assign_error: 2,
+        assoc_new: 2,
+        assoc_splat: 1,
+        assoclist_from_args: 1,
+        bare_assoc_hash: 1,
+        begin: 1,
+        binary: 3,
+        block_var: 2,
+        blockarg: 1,
+        bodystmt: 4,
+        brace_block: 2,
+        break: 1,
+        call: 3,
+        case: 2,
+        class: 3,
+        class_name_error: 2,
+        command: 2,
+        command_call: 4,
+        const_path_field: 2,
+        const_path_ref: 2,
+        const_ref: 1,
+        def: 3,
+        defined: 1,
+        defs: 5,
+        do_block: 2,
+        dot2: 2,
+        dot3: 2,
+        dyna_symbol: 1,
+        else: 1,
+        elsif: 3,
+        ensure: 1,
+        excessed_comma: 0,
+        fcall: 1,
+        field: 3,
+        fndptn: 4,
+        for: 3,
+        hash: 1,
+        heredoc_dedent: 2,
+        hshptn: 3,
+        if: 3,
+        if_mod: 2,
+        ifop: 3,
+        in: 3,
+        kwrest_param: 1,
+        lambda: 2,
+        magic_comment: 2,
+        massign: 2,
+        method_add_arg: 2,
+        method_add_block: 2,
+        mlhs_add: 2,
+        mlhs_add_post: 2,
+        mlhs_add_star: 2,
+        mlhs_new: 0,
+        mlhs_paren: 1,
+        module: 2,
+        mrhs_add: 2,
+        mrhs_add_star: 2,
+        mrhs_new: 0,
+        mrhs_new_from_args: 1,
+        next: 1,
+        nokw_param: 1,
+        opassign: 3,
+        operator_ambiguous: 2,
+        param_error: 2,
+        params: 7,
+        paren: 1,
+        parse_error: 1,
+        program: 1,
+        qsymbols_add: 2,
+        qsymbols_new: 0,
+        qwords_add: 2,
+        qwords_new: 0,
+        redo: 0,
+        regexp_add: 2,
+        regexp_literal: 2,
+        regexp_new: 0,
+        rescue: 4,
+        rescue_mod: 2,
+        rest_param: 1,
+        retry: 0,
+        return: 1,
+        return0: 0,
+        sclass: 2,
+        stmts_add: 2,
+        stmts_new: 0,
+        string_add: 2,
+        string_concat: 2,
+        string_content: 0,
+        string_dvar: 1,
+        string_embexpr: 1,
+        string_literal: 1,
+        super: 1,
+        symbol: 1,
+        symbol_literal: 1,
+        symbols_add: 2,
+        symbols_new: 0,
+        top_const_field: 1,
+        top_const_ref: 1,
+        unary: 2,
+        undef: 1,
+        unless: 3,
+        unless_mod: 2,
+        until: 2,
+        until_mod: 2,
+        var_alias: 2,
+        var_field: 1,
+        var_ref: 1,
+        vcall: 1,
+        void_stmt: 0,
+        when: 3,
+        while: 2,
+        while_mod: 2,
+        word_add: 2,
+        word_new: 0,
+        words_add: 2,
+        words_new: 0,
+        xstring_add: 2,
+        xstring_literal: 1,
+        xstring_new: 0,
+        yield: 1,
+        yield0: 0,
+        zsuper: 0
+      }
+
+      # This contains a table of all of the scanner events and their
+      # corresponding arity.
+      SCANNER_EVENT_TABLE = {
+        CHAR: 1,
+        __end__: 1,
+        backref: 1,
+        backtick: 1,
+        comma: 1,
+        comment: 1,
+        const: 1,
+        cvar: 1,
+        embdoc: 1,
+        embdoc_beg: 1,
+        embdoc_end: 1,
+        embexpr_beg: 1,
+        embexpr_end: 1,
+        embvar: 1,
+        float: 1,
+        gvar: 1,
+        heredoc_beg: 1,
+        heredoc_end: 1,
+        ident: 1,
+        ignored_nl: 1,
+        imaginary: 1,
+        int: 1,
+        ivar: 1,
+        kw: 1,
+        label: 1,
+        label_end: 1,
+        lbrace: 1,
+        lbracket: 1,
+        lparen: 1,
+        nl: 1,
+        op: 1,
+        period: 1,
+        qsymbols_beg: 1,
+        qwords_beg: 1,
+        rational: 1,
+        rbrace: 1,
+        rbracket: 1,
+        regexp_beg: 1,
+        regexp_end: 1,
+        rparen: 1,
+        semicolon: 1,
+        sp: 1,
+        symbeg: 1,
+        symbols_beg: 1,
+        tlambda: 1,
+        tlambeg: 1,
+        tstring_beg: 1,
+        tstring_content: 1,
+        tstring_end: 1,
+        words_beg: 1,
+        words_sep: 1,
+        ignored_sp: 1
+      }
+
+      # This array contains name of parser events.
+      PARSER_EVENTS = PARSER_EVENT_TABLE.keys
+
+      # This array contains name of scanner events.
+      SCANNER_EVENTS = SCANNER_EVENT_TABLE.keys
+
+      # This array contains name of all ripper events.
+      EVENTS = PARSER_EVENTS + SCANNER_EVENTS
+
+      # A list of all of the Ruby keywords.
+      KEYWORDS = [
+        "alias",
+        "and",
+        "begin",
+        "BEGIN",
+        "break",
+        "case",
+        "class",
+        "def",
+        "defined?",
+        "do",
+        "else",
+        "elsif",
+        "end",
+        "END",
+        "ensure",
+        "false",
+        "for",
+        "if",
+        "in",
+        "module",
+        "next",
+        "nil",
+        "not",
+        "or",
+        "redo",
+        "rescue",
+        "retry",
+        "return",
+        "self",
+        "super",
+        "then",
+        "true",
+        "undef",
+        "unless",
+        "until",
+        "when",
+        "while",
+        "yield",
+        "__ENCODING__",
+        "__FILE__",
+        "__LINE__"
+      ]
+
+      # A list of all of the Ruby binary operators.
+      BINARY_OPERATORS = [
+        :!=,
+        :!~,
+        :=~,
+        :==,
+        :===,
+        :<=>,
+        :>,
+        :>=,
+        :<,
+        :<=,
+        :&,
+        :|,
+        :^,
+        :>>,
+        :<<,
+        :-,
+        :+,
+        :%,
+        :/,
+        :*,
+        :**
+      ]
 
-        def _dispatch_event_new # :nodoc:
-          []
-        end
+      private_constant :KEYWORDS, :BINARY_OPERATORS
 
-        def _dispatch_event_push(list, item) # :nodoc:
-          list << item
-          list
+      # Parses +src+ and create S-exp tree.
+      # Returns more readable tree rather than Ripper.sexp_raw.
+      # This method is mainly for developer use.
+      # The +filename+ argument is mostly ignored.
+      # By default, this method does not handle syntax errors in +src+,
+      # returning +nil+ in such cases. Use the +raise_errors+ keyword
+      # to raise a SyntaxError for an error in +src+.
+      #
+      #   require "ripper"
+      #   require "pp"
+      #
+      #   pp Ripper.sexp("def m(a) nil end")
+      #     #=> [:program,
+      #          [[:def,
+      #           [:@ident, "m", [1, 4]],
+      #           [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]],
+      #           [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]]
+      #
+      def Ripper.sexp(src, filename = "-", lineno = 1, raise_errors: false)
+        builder = SexpBuilderPP.new(src, filename, lineno)
+        sexp = builder.parse
+        if builder.error?
+          if raise_errors
+            raise SyntaxError, builder.error
+          end
+        else
+          sexp
         end
+      end
 
-        ::Ripper::PARSER_EVENT_TABLE.each do |event, arity|
-          case event
-          when /_new\z/
-            alias_method :"on_#{event}", :_dispatch_event_new if arity == 0
-          when /_add\z/
-            alias_method :"on_#{event}", :_dispatch_event_push
+      # Parses +src+ and create S-exp tree.
+      # This method is mainly for developer use.
+      # The +filename+ argument is mostly ignored.
+      # By default, this method does not handle syntax errors in +src+,
+      # returning +nil+ in such cases. Use the +raise_errors+ keyword
+      # to raise a SyntaxError for an error in +src+.
+      #
+      #   require 'ripper'
+      #   require 'pp'
+      #
+      #   pp Ripper.sexp_raw("def m(a) nil end")
+      #     #=> [:program,
+      #          [:stmts_add,
+      #           [:stmts_new],
+      #           [:def,
+      #            [:@ident, "m", [1, 4]],
+      #            [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil]],
+      #            [:bodystmt,
+      #             [:stmts_add, [:stmts_new], [:var_ref, [:@kw, "nil", [1, 9]]]],
+      #             nil,
+      #             nil,
+      #             nil]]]]
+      #
+      def Ripper.sexp_raw(src, filename = "-", lineno = 1, raise_errors: false)
+        builder = SexpBuilder.new(src, filename, lineno)
+        sexp = builder.parse
+        if builder.error?
+          if raise_errors
+            raise SyntaxError, builder.error
           end
+        else
+          sexp
         end
       end
 
+      autoload :SexpBuilder, "prism/translation/ripper/sexp"
+      autoload :SexpBuilderPP, "prism/translation/ripper/sexp"
+
       # The source that is being parsed.
       attr_reader :source
 
+      # The filename of the source being parsed.
+      attr_reader :filename
+
       # The current line number of the parser.
       attr_reader :lineno
 
@@ -72,16 +441,17 @@ module Prism
       attr_reader :column
 
       # Create a new Translation::Ripper object with the given source.
-      def initialize(source)
+      def initialize(source, filename = "(ripper)", lineno = 1)
         @source = source
+        @filename = filename
+        @lineno = lineno
+        @column = 0
         @result = nil
-        @lineno = nil
-        @column = nil
       end
 
-      ############################################################################
+      ##########################################################################
       # Public interface
-      ############################################################################
+      ##########################################################################
 
       # True if the parser encountered an error during parsing.
       def error?
@@ -90,13 +460,80 @@ module Prism
 
       # Parse the source and return the result.
       def parse
+        result.comments.each do |comment|
+          location = comment.location
+          bounds(location)
+
+          if comment.is_a?(InlineComment)
+            on_comment(comment.slice)
+          else
+            offset = location.start_offset
+            lines = comment.slice.lines
+
+            lines.each_with_index do |line, index|
+              bounds(location.copy(start_offset: offset))
+
+              if index == 0
+                on_embdoc_beg(line)
+              elsif index == lines.size - 1
+                on_embdoc_end(line)
+              else
+                on_embdoc(line)
+              end
+
+              offset += line.bytesize
+            end
+          end
+        end
+
         result.magic_comments.each do |magic_comment|
           on_magic_comment(magic_comment.key, magic_comment.value)
         end
 
+        unless result.data_loc.nil?
+          on___end__(result.data_loc.slice.each_line.first)
+        end
+
+        result.warnings.each do |warning|
+          bounds(warning.location)
+
+          if warning.level == :default
+            warning(warning.message)
+          else
+            case warning.type
+            when :ambiguous_first_argument_plus
+              on_arg_ambiguous("+")
+            when :ambiguous_first_argument_minus
+              on_arg_ambiguous("-")
+            when :ambiguous_slash
+              on_arg_ambiguous("/")
+            else
+              warn(warning.message)
+            end
+          end
+        end
+
         if error?
           result.errors.each do |error|
-            on_parse_error(error.message)
+            location = error.location
+            bounds(location)
+
+            case error.type
+            when :alias_argument
+              on_alias_error("can't make alias for the number variables", location.slice)
+            when :argument_formal_class
+              on_param_error("formal argument cannot be a class variable", location.slice)
+            when :argument_format_constant
+              on_param_error("formal argument cannot be a constant", location.slice)
+            when :argument_formal_global
+              on_param_error("formal argument cannot be a global variable", location.slice)
+            when :argument_formal_ivar
+              on_param_error("formal argument cannot be an instance variable", location.slice)
+            when :class_name, :module_name
+              on_class_name_error("class/module name must be CONSTANT", location.slice)
+            else
+              on_parse_error(error.message)
+            end
           end
 
           nil
@@ -105,556 +542,2829 @@ module Prism
         end
       end
 
-      ############################################################################
+      ##########################################################################
       # Visitor methods
-      ############################################################################
+      ##########################################################################
+
+      # alias foo bar
+      # ^^^^^^^^^^^^^
+      def visit_alias_method_node(node)
+        new_name = visit(node.new_name)
+        old_name = visit(node.old_name)
 
-      # Visit an ArrayNode node.
-      def visit_array_node(node)
-        elements = visit_elements(node.elements) unless node.elements.empty?
         bounds(node.location)
-        on_array(elements)
+        on_alias(new_name, old_name)
       end
 
-      # Visit a CallNode node.
-      # Ripper distinguishes between many different method-call
-      # nodes -- unary and binary operators, "command" calls with
-      # no parentheses, and call/fcall/vcall.
-      def visit_call_node(node)
-        return visit_aref_node(node) if node.name == :[]
-        return visit_aref_field_node(node) if node.name == :[]=
-
-        if node.variable_call?
-          raise NotImplementedError unless node.receiver.nil?
-
-          bounds(node.message_loc)
-          return on_vcall(on_ident(node.message))
-        end
+      # alias $foo $bar
+      # ^^^^^^^^^^^^^^^
+      def visit_alias_global_variable_node(node)
+        new_name = visit_alias_global_variable_node_value(node.new_name)
+        old_name = visit_alias_global_variable_node_value(node.old_name)
 
-        if node.opening_loc.nil?
-          return visit_no_paren_call(node)
-        end
+        bounds(node.location)
+        on_var_alias(new_name, old_name)
+      end
 
-        # A non-operator method call with parentheses
+      # Visit one side of an alias global variable node.
+      private def visit_alias_global_variable_node_value(node)
+        bounds(node.location)
 
-        args = if node.arguments.nil?
-          on_arg_paren(nil)
+        case node
+        when BackReferenceReadNode
+          on_backref(node.slice)
+        when GlobalVariableReadNode
+          on_gvar(node.name.to_s)
         else
-          on_arg_paren(on_args_add_block(visit_elements(node.arguments.arguments), false))
+          raise
         end
+      end
 
-        bounds(node.message_loc)
-        ident_val = on_ident(node.message)
+      # foo => bar | baz
+      #        ^^^^^^^^^
+      def visit_alternation_pattern_node(node)
+        left = visit_pattern_node(node.left)
+        right = visit_pattern_node(node.right)
 
         bounds(node.location)
-        args_call_val = on_method_add_arg(on_fcall(ident_val), args)
-        if node.block
-          block_val = visit(node.block)
+        on_binary(left, :|, right)
+      end
 
-          return on_method_add_block(args_call_val, block_val)
+      # Visit a pattern within a pattern match. This is used to bypass the
+      # parenthesis node that can be used to wrap patterns.
+      private def visit_pattern_node(node)
+        if node.is_a?(ParenthesesNode)
+          visit(node.body)
         else
-          return args_call_val
+          visit(node)
         end
       end
 
-      # Visit a LocalVariableWriteNode.
-      def visit_local_variable_write_node(node)
-        bounds(node.name_loc)
-        ident_val = on_ident(node.name.to_s)
-        on_assign(on_var_field(ident_val), visit(node.value))
-      end
-
-      # Visit a LocalVariableAndWriteNode.
-      def visit_local_variable_and_write_node(node)
-        visit_binary_op_assign(node)
-      end
+      # a and b
+      # ^^^^^^^
+      def visit_and_node(node)
+        left = visit(node.left)
+        right = visit(node.right)
 
-      # Visit a LocalVariableOrWriteNode.
-      def visit_local_variable_or_write_node(node)
-        visit_binary_op_assign(node)
+        bounds(node.location)
+        on_binary(left, node.operator.to_sym, right)
       end
 
-      # Visit nodes for +=, *=, -=, etc., called LocalVariableOperatorWriteNodes.
-      def visit_local_variable_operator_write_node(node)
-        visit_binary_op_assign(node, operator: "#{node.operator}=")
-      end
+      # []
+      # ^^
+      def visit_array_node(node)
+        case (opening = node.opening)
+        when /^%w/
+          opening_loc = node.opening_loc
+          bounds(opening_loc)
+          on_qwords_beg(opening)
 
-      # Visit a LocalVariableReadNode.
-      def visit_local_variable_read_node(node)
-        bounds(node.location)
-        ident_val = on_ident(node.slice)
+          elements = on_qwords_new
+          previous = nil
 
-        on_var_ref(ident_val)
-      end
+          node.elements.each do |element|
+            visit_words_sep(opening_loc, previous, element)
 
-      # Visit a BlockNode.
-      def visit_block_node(node)
-        params_val = node.parameters.nil? ? nil : visit(node.parameters)
+            bounds(element.location)
+            elements = on_qwords_add(elements, on_tstring_content(element.content))
 
-        body_val = node.body.nil? ? on_stmts_add(on_stmts_new, on_void_stmt) : visit(node.body)
+            previous = element
+          end
 
-        on_brace_block(params_val, body_val)
-      end
+          bounds(node.closing_loc)
+          on_tstring_end(node.closing)
+        when /^%i/
+          opening_loc = node.opening_loc
+          bounds(opening_loc)
+          on_qsymbols_beg(opening)
 
-      # Visit a BlockParametersNode.
-      def visit_block_parameters_node(node)
-        on_block_var(visit(node.parameters), no_block_value)
-      end
+          elements = on_qsymbols_new
+          previous = nil
 
-      # Visit a ParametersNode.
-      # This will require expanding as we support more kinds of parameters.
-      def visit_parameters_node(node)
-        #on_params(required, optional, nil, nil, nil, nil, nil)
-        on_params(visit_all(node.requireds), nil, nil, nil, nil, nil, nil)
-      end
+          node.elements.each do |element|
+            visit_words_sep(opening_loc, previous, element)
 
-      # Visit a RequiredParameterNode.
-      def visit_required_parameter_node(node)
-        bounds(node.location)
-        on_ident(node.name.to_s)
-      end
+            bounds(element.location)
+            elements = on_qsymbols_add(elements, on_tstring_content(element.value))
 
-      # Visit a BreakNode.
-      def visit_break_node(node)
-        return on_break(on_args_new) if node.arguments.nil?
+            previous = element
+          end
 
-        args_val = visit_elements(node.arguments.arguments)
-        on_break(on_args_add_block(args_val, false))
-      end
+          bounds(node.closing_loc)
+          on_tstring_end(node.closing)
+        when /^%W/
+          opening_loc = node.opening_loc
+          bounds(opening_loc)
+          on_words_beg(opening)
+
+          elements = on_words_new
+          previous = nil
+
+          node.elements.each do |element|
+            visit_words_sep(opening_loc, previous, element)
+
+            bounds(element.location)
+            elements =
+              on_words_add(
+                elements,
+                if element.is_a?(StringNode)
+                  on_word_add(on_word_new, on_tstring_content(element.content))
+                else
+                  element.parts.inject(on_word_new) do |word, part|
+                    word_part =
+                      if part.is_a?(StringNode)
+                        bounds(part.location)
+                        on_tstring_content(part.content)
+                      else
+                        visit(part)
+                      end
+
+                    on_word_add(word, word_part)
+                  end
+                end
+              )
+
+            previous = element
+          end
 
-      # Visit an AliasMethodNode.
-      def visit_alias_method_node(node)
-        # For both the old and new name, if there is a colon in the symbol
-        # name (e.g. 'alias :foo :bar') then we do *not* emit the [:symbol] wrapper around
-        # the lexer token (e.g. :@ident) inside [:symbol_literal]. But if there
-        # is no colon (e.g. 'alias foo bar') then we *do* still emit the [:symbol] wrapper.
+          bounds(node.closing_loc)
+          on_tstring_end(node.closing)
+        when /^%I/
+          opening_loc = node.opening_loc
+          bounds(opening_loc)
+          on_symbols_beg(opening)
+
+          elements = on_symbols_new
+          previous = nil
+
+          node.elements.each do |element|
+            visit_words_sep(opening_loc, previous, element)
+
+            bounds(element.location)
+            elements =
+              on_symbols_add(
+                elements,
+                if element.is_a?(SymbolNode)
+                  on_word_add(on_word_new, on_tstring_content(element.value))
+                else
+                  element.parts.inject(on_word_new) do |word, part|
+                    word_part =
+                      if part.is_a?(StringNode)
+                        bounds(part.location)
+                        on_tstring_content(part.content)
+                      else
+                        visit(part)
+                      end
+
+                    on_word_add(word, word_part)
+                  end
+                end
+              )
+
+            previous = element
+          end
 
-        if node.new_name.is_a?(SymbolNode) && !node.new_name.opening
-          new_name_val = visit_symbol_literal_node(node.new_name, no_symbol_wrapper: true)
-        else
-          new_name_val = visit(node.new_name)
-        end
-        if node.old_name.is_a?(SymbolNode) && !node.old_name.opening
-          old_name_val = visit_symbol_literal_node(node.old_name, no_symbol_wrapper: true)
+          bounds(node.closing_loc)
+          on_tstring_end(node.closing)
         else
-          old_name_val = visit(node.old_name)
+          bounds(node.opening_loc)
+          on_lbracket(opening)
+
+          elements = visit_arguments(node.elements) unless node.elements.empty?
+
+          bounds(node.closing_loc)
+          on_rbracket(node.closing)
         end
 
-        on_alias(new_name_val, old_name_val)
+        bounds(node.location)
+        on_array(elements)
       end
 
-      # Visit an AliasGlobalVariableNode.
-      def visit_alias_global_variable_node(node)
-        on_var_alias(visit(node.new_name), visit(node.old_name))
+      # Dispatch a words_sep event that contains the space 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))
+        end
       end
 
-      # Visit a GlobalVariableReadNode.
-      def visit_global_variable_read_node(node)
-        bounds(node.location)
-        on_gvar(node.name.to_s)
+      # Visit a list of elements, like the elements of an array or arguments.
+      private def visit_arguments(elements)
+        bounds(elements.first.location)
+        elements.inject(on_args_new) do |args, element|
+          arg = visit(element)
+          bounds(element.location)
+
+          case element
+          when BlockArgumentNode
+            on_args_add_block(args, arg)
+          when SplatNode
+            on_args_add_star(args, arg)
+          else
+            on_args_add(args, arg)
+          end
+        end
       end
 
-      # Visit a BackReferenceReadNode.
-      def visit_back_reference_read_node(node)
+      # foo => [bar]
+      #        ^^^^^
+      def visit_array_pattern_node(node)
+        constant = visit(node.constant)
+        requireds = visit_all(node.requireds) if node.requireds.any?
+        rest =
+          if (rest_node = node.rest).is_a?(SplatNode)
+            if rest_node.expression.nil?
+              bounds(rest_node.location)
+              on_var_field(nil)
+            else
+              visit(rest_node.expression)
+            end
+          end
+
+        posts = visit_all(node.posts) if node.posts.any?
+
         bounds(node.location)
-        on_backref(node.name.to_s)
+        on_aryptn(constant, requireds, rest, posts)
       end
 
-      # Visit an AndNode.
-      def visit_and_node(node)
-        visit_binary_operator(node)
+      # foo(bar)
+      #     ^^^
+      def visit_arguments_node(node)
+        arguments, _ = visit_call_node_arguments(node, nil, false)
+        arguments
       end
 
-      # Visit an OrNode.
-      def visit_or_node(node)
-        visit_binary_operator(node)
-      end
+      # { a: 1 }
+      #   ^^^^
+      def visit_assoc_node(node)
+        key = visit(node.key)
+        value = visit(node.value)
 
-      # Visit a TrueNode.
-      def visit_true_node(node)
         bounds(node.location)
-        on_var_ref(on_kw("true"))
+        on_assoc_new(key, value)
       end
 
-      # Visit a FalseNode.
-      def visit_false_node(node)
+      # def foo(**); bar(**); end
+      #                  ^^
+      #
+      # { **foo }
+      #   ^^^^^
+      def visit_assoc_splat_node(node)
+        value = visit(node.value)
+
         bounds(node.location)
-        on_var_ref(on_kw("false"))
+        on_assoc_splat(value)
       end
 
-      # Visit a FloatNode node.
-      def visit_float_node(node)
-        visit_number(node) { |text| on_float(text) }
+      # $+
+      # ^^
+      def visit_back_reference_read_node(node)
+        bounds(node.location)
+        on_backref(node.slice)
       end
 
-      # Visit a ImaginaryNode node.
-      def visit_imaginary_node(node)
-        visit_number(node) { |text| on_imaginary(text) }
-      end
+      # begin end
+      # ^^^^^^^^^
+      def visit_begin_node(node)
+        clauses = visit_begin_node_clauses(node.begin_keyword_loc, node, false)
 
-      # Visit an IntegerNode node.
-      def visit_integer_node(node)
-        visit_number(node) { |text| on_int(text) }
+        bounds(node.location)
+        on_begin(clauses)
       end
 
-      # Visit a ParenthesesNode node.
-      def visit_parentheses_node(node)
-        body =
-          if node.body.nil?
+      # Visit the clauses of a begin node to form an on_bodystmt call.
+      private def visit_begin_node_clauses(location, node, allow_newline)
+        statements =
+          if node.statements.nil?
             on_stmts_add(on_stmts_new, on_void_stmt)
           else
-            visit(node.body)
+            body = node.statements.body
+            body.unshift(nil) if void_stmt?(location, node.statements.body[0].location, allow_newline)
+
+            bounds(node.statements.location)
+            visit_statements_node_body(body)
           end
 
+        rescue_clause = visit(node.rescue_clause)
+        else_clause =
+          unless (else_clause_node = node.else_clause).nil?
+            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
+              end
+
+            bounds(else_clause_node.location)
+            visit_statements_node_body(else_statements)
+          end
+        ensure_clause = visit(node.ensure_clause)
+
         bounds(node.location)
-        on_paren(body)
+        on_bodystmt(statements, rescue_clause, else_clause, ensure_clause)
       end
 
-      # Visit a BeginNode node.
-      # This is not at all bulletproof against different structures of begin/rescue/else/ensure/end.
-      def visit_begin_node(node)
-        rescue_val = node.rescue_clause ? on_rescue(nil, nil, visit(node.rescue_clause), nil) : nil
-        ensure_val = node.ensure_clause ? on_ensure(visit(node.ensure_clause.statements)) : nil
-        on_begin(on_bodystmt(visit(node.statements), rescue_val, nil, ensure_val))
+      # Visit the body of a structure that can have either a set of statements
+      # or statements wrapped in rescue/else/ensure.
+      private def visit_body_node(location, node, allow_newline = false)
+        case node
+        when nil
+          bounds(location)
+          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)
+          stmts = visit_statements_node_body(body)
+
+          bounds(node.body.first.location)
+          on_bodystmt(stmts, nil, nil, nil)
+        when BeginNode
+          visit_begin_node_clauses(location, node, allow_newline)
+        else
+          raise
+        end
       end
 
-      # Visit a RescueNode node.
-      def visit_rescue_node(node)
-        visit(node.statements)
+      # foo(&bar)
+      #     ^^^^
+      def visit_block_argument_node(node)
+        visit(node.expression)
       end
 
-      # Visit a ProgramNode node.
-      def visit_program_node(node)
-        statements = visit(node.statements)
+      # foo { |; bar| }
+      #          ^^^
+      def visit_block_local_variable_node(node)
         bounds(node.location)
-        on_program(statements)
+        on_ident(node.name.to_s)
       end
 
-      # Visit a RangeNode node.
-      def visit_range_node(node)
-        left = visit(node.left)
-        right = visit(node.right)
+      # Visit a BlockNode.
+      def visit_block_node(node)
+        braces = node.opening == "{"
+        parameters = visit(node.parameters)
 
-        bounds(node.location)
-        if node.exclude_end?
-          on_dot3(left, right)
+        body =
+          case node.body
+          when nil
+            bounds(node.location)
+            stmts = on_stmts_add(on_stmts_new, on_void_stmt)
+
+            bounds(node.location)
+            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 = visit_statements_node_body(stmts)
+
+            bounds(node.body.location)
+            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
+          when BeginNode
+            visit_body_node(node.parameters&.location || node.opening_loc, node.body)
+          else
+            raise
+          end
+
+        if braces
+          bounds(node.location)
+          on_brace_block(parameters, body)
         else
-          on_dot2(left, right)
+          bounds(node.location)
+          on_do_block(parameters, body)
         end
       end
 
-      # Visit a RationalNode node.
-      def visit_rational_node(node)
-        visit_number(node) { |text| on_rational(text) }
-      end
-
-      # Visit a StringNode node.
-      def visit_string_node(node)
-        bounds(node.content_loc)
-        tstring_val = on_tstring_content(node.unescaped.to_s)
-        on_string_literal(on_string_add(on_string_content, tstring_val))
-      end
-
-      # Visit an XStringNode node.
-      def visit_x_string_node(node)
-        bounds(node.content_loc)
-        tstring_val = on_tstring_content(node.unescaped.to_s)
-        on_xstring_literal(on_xstring_add(on_xstring_new, tstring_val))
-      end
-
-      # Visit an InterpolatedStringNode node.
-      def visit_interpolated_string_node(node)
-        on_string_literal(visit_enumerated_node(node))
-      end
+      # def foo(&bar); end
+      #         ^^^^
+      def visit_block_parameter_node(node)
+        if node.name_loc.nil?
+          bounds(node.location)
+          on_blockarg(nil)
+        else
+          bounds(node.name_loc)
+          name = visit_token(node.name.to_s)
 
-      # Visit an EmbeddedStatementsNode node.
-      def visit_embedded_statements_node(node)
-        visit(node.statements)
+          bounds(node.location)
+          on_blockarg(name)
+        end
       end
 
-      # Visit a SymbolNode node.
-      def visit_symbol_node(node)
-        visit_symbol_literal_node(node)
-      end
+      # A block's parameters.
+      def visit_block_parameters_node(node)
+        parameters =
+          if node.parameters.nil?
+            on_params(nil, nil, nil, nil, nil, nil, nil)
+          else
+            visit(node.parameters)
+          end
 
-      # Visit an InterpolatedSymbolNode node.
-      def visit_interpolated_symbol_node(node)
-        on_dyna_symbol(visit_enumerated_node(node))
-      end
+        locals =
+          if node.locals.any?
+            visit_all(node.locals)
+          else
+            false
+          end
 
-      # Visit a StatementsNode node.
-      def visit_statements_node(node)
         bounds(node.location)
-        node.body.inject(on_stmts_new) do |stmts, stmt|
-          on_stmts_add(stmts, visit(stmt))
-        end
+        on_block_var(parameters, locals)
       end
 
-      ############################################################################
-      # Entrypoints for subclasses
-      ############################################################################
+      # break
+      # ^^^^^
+      #
+      # break foo
+      # ^^^^^^^^^
+      def visit_break_node(node)
+        if node.arguments.nil?
+          bounds(node.location)
+          on_break(on_args_new)
+        else
+          arguments = visit(node.arguments)
 
-      # This is a convenience method that runs the SexpBuilder subclass parser.
-      def self.sexp_raw(source)
-        SexpBuilder.new(source).parse
+          bounds(node.location)
+          on_break(arguments)
+        end
       end
 
-      # This is a convenience method that runs the SexpBuilderPP subclass parser.
-      def self.sexp(source)
-        SexpBuilderPP.new(source).parse
-      end
+      # foo
+      # ^^^
+      #
+      # foo.bar
+      # ^^^^^^^
+      #
+      # foo.bar() {}
+      # ^^^^^^^^^^^^
+      def visit_call_node(node)
+        if node.call_operator_loc.nil?
+          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))
 
-      private
+            bounds(node.location)
+            call = on_aref(receiver, arguments)
 
-      # Generate Ripper events for a CallNode with no opening_loc
-      def visit_no_paren_call(node)
-        # No opening_loc can mean an operator. It can also mean a
-        # method call with no parentheses.
-        if node.message.match?(/^[[:punct:]]/)
-          left = visit(node.receiver)
-          if node.arguments&.arguments&.length == 1
-            right = visit(node.arguments.arguments.first)
-
-            return on_binary(left, node.name, right)
-          elsif !node.arguments || node.arguments.empty?
-            return on_unary(node.name, left)
+            if block.nil?
+              call
+            else
+              bounds(node.location)
+              on_method_add_block(call, block)
+            end
+          when :[]=
+            receiver = visit(node.receiver)
+
+            *arguments, last_argument = node.arguments.arguments
+            arguments << node.block if !node.block.nil?
+
+            arguments =
+              if arguments.any?
+                args = visit_arguments(arguments)
+
+                if !node.block.nil?
+                  args
+                else
+                  bounds(arguments.first.location)
+                  on_args_add_block(args, false)
+                end
+              end
+
+            bounds(node.location)
+            call = on_aref_field(receiver, arguments)
+            value = visit_write_value(last_argument)
+
+            bounds(last_argument.location)
+            on_assign(call, value)
+          when :-@, :+@, :~
+            receiver = visit(node.receiver)
+
+            bounds(node.location)
+            on_unary(node.name, receiver)
+          when :!
+            receiver = visit(node.receiver)
+
+            bounds(node.location)
+            on_unary(node.message == "not" ? :not : :!, receiver)
+          when *BINARY_OPERATORS
+            receiver = visit(node.receiver)
+            value = visit(node.arguments.arguments.first)
+
+            bounds(node.location)
+            on_binary(receiver, node.name, value)
           else
-            raise NotImplementedError, "More than two arguments for operator"
-          end
-        elsif node.call_operator_loc.nil?
-          # In Ripper a method call like "puts myvar" with no parentheses is a "command".
-          bounds(node.message_loc)
-          ident_val = on_ident(node.message)
+            bounds(node.message_loc)
+            message = visit_token(node.message, false)
 
-          # Unless it has a block, and then it's an fcall (e.g. "foo { bar }")
-          if node.block
-            block_val = visit(node.block)
-            # In these calls, even if node.arguments is nil, we still get an :args_new call.
-            args = if node.arguments.nil?
-              on_args_new
+            if node.variable_call?
+              on_vcall(message)
             else
-              on_args_add_block(visit_elements(node.arguments.arguments))
+              arguments, block = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))
+              call =
+                if node.opening_loc.nil? && arguments&.any?
+                  bounds(node.location)
+                  on_command(message, arguments)
+                elsif !node.opening_loc.nil?
+                  bounds(node.location)
+                  on_method_add_arg(on_fcall(message), on_arg_paren(arguments))
+                else
+                  bounds(node.location)
+                  on_method_add_arg(on_fcall(message), on_args_new)
+                end
+
+              if block.nil?
+                call
+              else
+                bounds(node.block.location)
+                on_method_add_block(call, block)
+              end
+            end
+          end
+        else
+          receiver = visit(node.receiver)
+
+          bounds(node.call_operator_loc)
+          call_operator = visit_token(node.call_operator)
+
+          message =
+            if node.message_loc.nil?
+              :call
+            else
+              bounds(node.message_loc)
+              visit_token(node.message, false)
+            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))
+            call =
+              if node.opening_loc.nil?
+                bounds(node.location)
+
+                if node.arguments.nil? && !node.block.is_a?(BlockArgumentNode)
+                  on_call(receiver, call_operator, message)
+                else
+                  on_command_call(receiver, call_operator, message, arguments)
+                end
+              else
+                bounds(node.opening_loc)
+                arguments = on_arg_paren(arguments)
+
+                bounds(node.location)
+                on_method_add_arg(on_call(receiver, call_operator, message), arguments)
+              end
+
+            if block.nil?
+              call
+            else
+              bounds(node.block.location)
+              on_method_add_block(call, block)
+            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)
+        arguments = arguments_node&.arguments || []
+        block = block_node
+
+        if block.is_a?(BlockArgumentNode)
+          arguments << block
+          block = nil
+        end
+
+        [
+          if arguments.length == 1 && arguments.first.is_a?(ForwardingArgumentsNode)
+            visit(arguments.first)
+          elsif arguments.any?
+            args = visit_arguments(arguments)
+
+            if block_node.is_a?(BlockArgumentNode) || arguments.last.is_a?(ForwardingArgumentsNode) || command?(arguments.last) || trailing_comma
+              args
+            else
+              bounds(arguments.first.location)
+              on_args_add_block(args, false)
+            end
+          end,
+          visit(block)
+        ]
+      end
+
+      # Returns true if the given node is a command node.
+      private def command?(node)
+        node.is_a?(CallNode) &&
+          node.opening_loc.nil? &&
+          (!node.arguments.nil? || node.block.is_a?(BlockArgumentNode)) &&
+          !BINARY_OPERATORS.include?(node.name)
+      end
+
+      # foo.bar += baz
+      # ^^^^^^^^^^^^^^^
+      def visit_call_operator_write_node(node)
+        receiver = visit(node.receiver)
+
+        bounds(node.call_operator_loc)
+        call_operator = visit_token(node.call_operator)
+
+        bounds(node.message_loc)
+        message = visit_token(node.message)
+
+        bounds(node.location)
+        target = on_field(receiver, call_operator, message)
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo.bar &&= baz
+      # ^^^^^^^^^^^^^^^
+      def visit_call_and_write_node(node)
+        receiver = visit(node.receiver)
+
+        bounds(node.call_operator_loc)
+        call_operator = visit_token(node.call_operator)
+
+        bounds(node.message_loc)
+        message = visit_token(node.message)
+
+        bounds(node.location)
+        target = on_field(receiver, call_operator, message)
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo.bar ||= baz
+      # ^^^^^^^^^^^^^^^
+      def visit_call_or_write_node(node)
+        receiver = visit(node.receiver)
+
+        bounds(node.call_operator_loc)
+        call_operator = visit_token(node.call_operator)
+
+        bounds(node.message_loc)
+        message = visit_token(node.message)
+
+        bounds(node.location)
+        target = on_field(receiver, call_operator, message)
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo.bar, = 1
+      # ^^^^^^^
+      def visit_call_target_node(node)
+        if node.call_operator == "::"
+          receiver = visit(node.receiver)
+
+          bounds(node.message_loc)
+          message = visit_token(node.message)
+
+          bounds(node.location)
+          on_const_path_field(receiver, message)
+        else
+          receiver = visit(node.receiver)
+
+          bounds(node.call_operator_loc)
+          call_operator = visit_token(node.call_operator)
+
+          bounds(node.message_loc)
+          message = visit_token(node.message)
+
+          bounds(node.location)
+          on_field(receiver, call_operator, message)
+        end
+      end
+
+      # foo => bar => baz
+      #        ^^^^^^^^^^
+      def visit_capture_pattern_node(node)
+        value = visit(node.value)
+        target = visit(node.target)
+
+        bounds(node.location)
+        on_binary(value, :"=>", target)
+      end
+
+      # case foo; when bar; end
+      # ^^^^^^^^^^^^^^^^^^^^^^^
+      def visit_case_node(node)
+        predicate = visit(node.predicate)
+        clauses =
+          node.conditions.reverse_each.inject(visit(node.consequent)) do |consequent, condition|
+            on_when(*visit(condition), consequent)
+          end
+
+        bounds(node.location)
+        on_case(predicate, clauses)
+      end
+
+      # case foo; in bar; end
+      # ^^^^^^^^^^^^^^^^^^^^^
+      def visit_case_match_node(node)
+        predicate = visit(node.predicate)
+        clauses =
+          node.conditions.reverse_each.inject(visit(node.consequent)) do |consequent, condition|
+            on_in(*visit(condition), consequent)
+          end
+
+        bounds(node.location)
+        on_case(predicate, clauses)
+      end
+
+      # class Foo; end
+      # ^^^^^^^^^^^^^^
+      def visit_class_node(node)
+        constant_path =
+          if node.constant_path.is_a?(ConstantReadNode)
+            bounds(node.constant_path.location)
+            on_const_ref(on_const(node.constant_path.name.to_s))
+          else
+            visit(node.constant_path)
+          end
+
+        superclass = visit(node.superclass)
+        bodystmt = visit_body_node(node.superclass&.location || node.constant_path.location, node.body, node.superclass.nil?)
+
+        bounds(node.location)
+        on_class(constant_path, superclass, bodystmt)
+      end
+
+      # @@foo
+      # ^^^^^
+      def visit_class_variable_read_node(node)
+        bounds(node.location)
+        on_var_ref(on_cvar(node.slice))
+      end
+
+      # @@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))
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # @@foo += bar
+      # ^^^^^^^^^^^^
+      def visit_class_variable_operator_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_cvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @@foo &&= bar
+      # ^^^^^^^^^^^^^
+      def visit_class_variable_and_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_cvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @@foo ||= bar
+      # ^^^^^^^^^^^^^
+      def visit_class_variable_or_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_cvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @@foo, = bar
+      # ^^^^^
+      def visit_class_variable_target_node(node)
+        bounds(node.location)
+        on_var_field(on_cvar(node.name.to_s))
+      end
+
+      # Foo
+      # ^^^
+      def visit_constant_read_node(node)
+        bounds(node.location)
+        on_var_ref(on_const(node.name.to_s))
+      end
+
+      # 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))
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # Foo += bar
+      # ^^^^^^^^^^^
+      def visit_constant_operator_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_const(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo &&= bar
+      # ^^^^^^^^^^^^
+      def visit_constant_and_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_const(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo ||= bar
+      # ^^^^^^^^^^^^
+      def visit_constant_or_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_const(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo, = bar
+      # ^^^
+      def visit_constant_target_node(node)
+        bounds(node.location)
+        on_var_field(on_const(node.name.to_s))
+      end
+
+      # Foo::Bar
+      # ^^^^^^^^
+      def visit_constant_path_node(node)
+        if node.parent.nil?
+          bounds(node.child.location)
+          child = on_const(node.child.name.to_s)
+
+          bounds(node.location)
+          on_top_const_ref(child)
+        else
+          parent = visit(node.parent)
+
+          bounds(node.child.location)
+          child = on_const(node.child.name.to_s)
+
+          bounds(node.location)
+          on_const_path_ref(parent, child)
+        end
+      end
+
+      # Foo::Bar = 1
+      # ^^^^^^^^^^^^
+      #
+      # Foo::Foo, Bar::Bar = 1
+      # ^^^^^^^^  ^^^^^^^^
+      def visit_constant_path_write_node(node)
+        target = visit_constant_path_write_node_target(node.target)
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # Visit a constant path that is part of a write node.
+      private def visit_constant_path_write_node_target(node)
+        if node.parent.nil?
+          bounds(node.child.location)
+          child = on_const(node.child.name.to_s)
+
+          bounds(node.location)
+          on_top_const_field(child)
+        else
+          parent = visit(node.parent)
+
+          bounds(node.child.location)
+          child = on_const(node.child.name.to_s)
+
+          bounds(node.location)
+          on_const_path_field(parent, child)
+        end
+      end
+
+      # Foo::Bar += baz
+      # ^^^^^^^^^^^^^^^
+      def visit_constant_path_operator_write_node(node)
+        target = visit_constant_path_write_node_target(node.target)
+        value = visit(node.value)
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo::Bar &&= baz
+      # ^^^^^^^^^^^^^^^^
+      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("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo::Bar ||= baz
+      # ^^^^^^^^^^^^^^^^
+      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("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # Foo::Bar, = baz
+      # ^^^^^^^^
+      def visit_constant_path_target_node(node)
+        visit_constant_path_write_node_target(node)
+      end
+
+      # def foo; end
+      # ^^^^^^^^^^^^
+      #
+      # def self.foo; end
+      # ^^^^^^^^^^^^^^^^^
+      def visit_def_node(node)
+        receiver = visit(node.receiver)
+        operator =
+          if !node.operator_loc.nil?
+            bounds(node.operator_loc)
+            visit_token(node.operator)
+          end
+
+        bounds(node.name_loc)
+        name = visit_token(node.name_loc.slice)
+
+        parameters =
+          if node.parameters.nil?
+            bounds(node.location)
+            on_params(nil, nil, nil, nil, nil, nil, nil)
+          else
+            visit(node.parameters)
+          end
+
+        if !node.lparen_loc.nil?
+          bounds(node.lparen_loc)
+          parameters = on_paren(parameters)
+        end
+
+        bodystmt =
+          if node.equal_loc.nil?
+            visit_body_node(node.rparen_loc || node.end_keyword_loc, node.body)
+          else
+            body = visit(node.body.body.first)
+
+            bounds(node.body.location)
+            on_bodystmt(body, nil, nil, nil)
+          end
+
+        bounds(node.location)
+        if receiver.nil?
+          on_def(name, parameters, bodystmt)
+        else
+          on_defs(receiver, operator, name, parameters, bodystmt)
+        end
+      end
+
+      # defined? a
+      # ^^^^^^^^^^
+      #
+      # defined?(a)
+      # ^^^^^^^^^^^
+      def visit_defined_node(node)
+        bounds(node.location)
+        on_defined(visit(node.value))
+      end
+
+      # if foo then bar else baz end
+      #                 ^^^^^^^^^^^^
+      def visit_else_node(node)
+        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
+          end
+
+        bounds(node.location)
+        on_else(visit_statements_node_body(statements))
+      end
+
+      # "foo #{bar}"
+      #      ^^^^^^
+      def visit_embedded_statements_node(node)
+        bounds(node.opening_loc)
+        on_embexpr_beg(node.opening)
+
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        bounds(node.closing_loc)
+        on_embexpr_end(node.closing)
+
+        bounds(node.location)
+        on_string_embexpr(statements)
+      end
+
+      # "foo #@bar"
+      #      ^^^^^
+      def visit_embedded_variable_node(node)
+        bounds(node.operator_loc)
+        on_embvar(node.operator)
+
+        variable = visit(node.variable)
+
+        bounds(node.location)
+        on_string_dvar(variable)
+      end
+
+      # Visit an EnsureNode node.
+      def visit_ensure_node(node)
+        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
+          end
+
+        statements = visit_statements_node_body(statements)
+
+        bounds(node.location)
+        on_ensure(statements)
+      end
+
+      # false
+      # ^^^^^
+      def visit_false_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("false"))
+      end
+
+      # foo => [*, bar, *]
+      #        ^^^^^^^^^^^
+      def visit_find_pattern_node(node)
+        constant = visit(node.constant)
+        left =
+          if node.left.expression.nil?
+            bounds(node.left.location)
+            on_var_field(nil)
+          else
+            visit(node.left.expression)
+          end
+
+        requireds = visit_all(node.requireds) if node.requireds.any?
+        right =
+          if node.right.expression.nil?
+            bounds(node.right.location)
+            on_var_field(nil)
+          else
+            visit(node.right.expression)
+          end
+
+        bounds(node.location)
+        on_fndptn(constant, left, requireds, right)
+      end
+
+      # if foo .. bar; end
+      #    ^^^^^^^^^^
+      def visit_flip_flop_node(node)
+        left = visit(node.left)
+        right = visit(node.right)
+
+        bounds(node.location)
+        if node.exclude_end?
+          on_dot3(left, right)
+        else
+          on_dot2(left, right)
+        end
+      end
+
+      # 1.0
+      # ^^^
+      def visit_float_node(node)
+        visit_number_node(node) { |text| on_float(text) }
+      end
+
+      # for foo in bar do end
+      # ^^^^^^^^^^^^^^^^^^^^^
+      def visit_for_node(node)
+        index = visit(node.index)
+        collection = visit(node.collection)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        bounds(node.location)
+        on_for(index, collection, statements)
+      end
+
+      # def foo(...); bar(...); end
+      #                   ^^^
+      def visit_forwarding_arguments_node(node)
+        bounds(node.location)
+        on_args_forward
+      end
+
+      # def foo(...); end
+      #         ^^^
+      def visit_forwarding_parameter_node(node)
+        bounds(node.location)
+        on_args_forward
+      end
+
+      # super
+      # ^^^^^
+      #
+      # super {}
+      # ^^^^^^^^
+      def visit_forwarding_super_node(node)
+        if node.block.nil?
+          bounds(node.location)
+          on_zsuper
+        else
+          block = visit(node.block)
+
+          bounds(node.location)
+          on_method_add_block(on_zsuper, block)
+        end
+      end
+
+      # $foo
+      # ^^^^
+      def visit_global_variable_read_node(node)
+        bounds(node.location)
+        on_var_ref(on_gvar(node.name.to_s))
+      end
+
+      # $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))
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # $foo += bar
+      # ^^^^^^^^^^^
+      def visit_global_variable_operator_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_gvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # $foo &&= bar
+      # ^^^^^^^^^^^^
+      def visit_global_variable_and_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_gvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # $foo ||= bar
+      # ^^^^^^^^^^^^
+      def visit_global_variable_or_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_gvar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # $foo, = bar
+      # ^^^^
+      def visit_global_variable_target_node(node)
+        bounds(node.location)
+        on_var_field(on_gvar(node.name.to_s))
+      end
+
+      # {}
+      # ^^
+      def visit_hash_node(node)
+        elements =
+          if node.elements.any?
+            args = visit_all(node.elements)
+
+            bounds(node.elements.first.location)
+            on_assoclist_from_args(args)
+          end
+
+        bounds(node.location)
+        on_hash(elements)
+      end
+
+      # foo => {}
+      #        ^^
+      def visit_hash_pattern_node(node)
+        constant = visit(node.constant)
+        elements =
+          if node.elements.any? || !node.rest.nil?
+            node.elements.map do |element|
+              [
+                if (key = element.key).opening_loc.nil?
+                  visit(key)
+                else
+                  bounds(key.value_loc)
+                  if (value = key.value).empty?
+                    on_string_content
+                  else
+                    on_string_add(on_string_content, on_tstring_content(value))
+                  end
+                end,
+                visit(element.value)
+              ]
+            end
+          end
+
+        rest =
+          case node.rest
+          when AssocSplatNode
+            visit(node.rest.value)
+          when NoKeywordsParameterNode
+            bounds(node.rest.location)
+            on_var_field(visit(node.rest))
+          end
+
+        bounds(node.location)
+        on_hshptn(constant, elements, rest)
+      end
+
+      # if foo then bar end
+      # ^^^^^^^^^^^^^^^^^^^
+      #
+      # bar if foo
+      # ^^^^^^^^^^
+      #
+      # foo ? bar : baz
+      # ^^^^^^^^^^^^^^^
+      def visit_if_node(node)
+        if node.then_keyword == "?"
+          predicate = visit(node.predicate)
+          truthy = visit(node.statements.body.first)
+          falsy = visit(node.consequent.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)
+          predicate = visit(node.predicate)
+          statements =
+            if node.statements.nil?
+              bounds(node.location)
+              on_stmts_add(on_stmts_new, on_void_stmt)
+            else
+              visit(node.statements)
+            end
+          consequent = visit(node.consequent)
+
+          bounds(node.location)
+          if node.if_keyword == "if"
+            on_if(predicate, statements, consequent)
+          else
+            on_elsif(predicate, statements, consequent)
+          end
+        else
+          statements = visit(node.statements.body.first)
+          predicate = visit(node.predicate)
+
+          bounds(node.location)
+          on_if_mod(predicate, statements)
+        end
+      end
+
+      # 1i
+      # ^^
+      def visit_imaginary_node(node)
+        visit_number_node(node) { |text| on_imaginary(text) }
+      end
+
+      # { foo: }
+      #   ^^^^
+      def visit_implicit_node(node)
+      end
+
+      # foo { |bar,| }
+      #           ^
+      def visit_implicit_rest_node(node)
+        bounds(node.location)
+        on_excessed_comma
+      end
+
+      # case foo; in bar; end
+      # ^^^^^^^^^^^^^^^^^^^^^
+      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 consequent. Instead, we'll return
+        # the component parts and let the parent node handle it.
+        pattern = visit_pattern_node(node.pattern)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        [pattern, statements]
+      end
+
+      # foo[bar] += baz
+      # ^^^^^^^^^^^^^^^
+      def visit_index_operator_write_node(node)
+        receiver = visit(node.receiver)
+        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+        bounds(node.location)
+        target = on_aref_field(receiver, arguments)
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo[bar] &&= baz
+      # ^^^^^^^^^^^^^^^^
+      def visit_index_and_write_node(node)
+        receiver = visit(node.receiver)
+        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+        bounds(node.location)
+        target = on_aref_field(receiver, arguments)
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo[bar] ||= baz
+      # ^^^^^^^^^^^^^^^^
+      def visit_index_or_write_node(node)
+        receiver = visit(node.receiver)
+        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+        bounds(node.location)
+        target = on_aref_field(receiver, arguments)
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo[bar], = 1
+      # ^^^^^^^^
+      def visit_index_target_node(node)
+        receiver = visit(node.receiver)
+        arguments, _ = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))
+
+        bounds(node.location)
+        on_aref_field(receiver, arguments)
+      end
+
+      # @foo
+      # ^^^^
+      def visit_instance_variable_read_node(node)
+        bounds(node.location)
+        on_var_ref(on_ivar(node.name.to_s))
+      end
+
+      # @foo = 1
+      # ^^^^^^^^
+      def visit_instance_variable_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ivar(node.name.to_s))
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # @foo += bar
+      # ^^^^^^^^^^^
+      def visit_instance_variable_operator_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ivar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @foo &&= bar
+      # ^^^^^^^^^^^^
+      def visit_instance_variable_and_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ivar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @foo ||= bar
+      # ^^^^^^^^^^^^
+      def visit_instance_variable_or_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ivar(node.name.to_s))
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # @foo, = bar
+      # ^^^^
+      def visit_instance_variable_target_node(node)
+        bounds(node.location)
+        on_var_field(on_ivar(node.name.to_s))
+      end
+
+      # 1
+      # ^
+      def visit_integer_node(node)
+        visit_number_node(node) { |text| on_int(text) }
+      end
+
+      # if /foo #{bar}/ then end
+      #    ^^^^^^^^^^^^
+      def visit_interpolated_match_last_line_node(node)
+        bounds(node.opening_loc)
+        on_regexp_beg(node.opening)
+
+        bounds(node.parts.first.location)
+        parts =
+          node.parts.inject(on_regexp_new) do |content, part|
+            on_regexp_add(content, visit_string_content(part))
+          end
+
+        bounds(node.closing_loc)
+        closing = on_regexp_end(node.closing)
+
+        bounds(node.location)
+        on_regexp_literal(parts, closing)
+      end
+
+      # /foo #{bar}/
+      # ^^^^^^^^^^^^
+      def visit_interpolated_regular_expression_node(node)
+        bounds(node.opening_loc)
+        on_regexp_beg(node.opening)
+
+        bounds(node.parts.first.location)
+        parts =
+          node.parts.inject(on_regexp_new) do |content, part|
+            on_regexp_add(content, visit_string_content(part))
+          end
+
+        bounds(node.closing_loc)
+        closing = on_regexp_end(node.closing)
+
+        bounds(node.location)
+        on_regexp_literal(parts, closing)
+      end
+
+      # "foo #{bar}"
+      # ^^^^^^^^^^^^
+      def visit_interpolated_string_node(node)
+        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(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(node.location)
+          on_string_literal(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)
+
+          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)
+        end
+      end
+
+      # Visit an individual part of a string-like node.
+      private def visit_string_content(part)
+        if part.is_a?(StringNode)
+          bounds(part.content_loc)
+          on_tstring_content(part.content)
+        else
+          visit(part)
+        end
+      end
+
+      # -> { it }
+      # ^^^^^^^^^
+      def visit_it_parameters_node(node)
+      end
+
+      # foo(bar: baz)
+      #     ^^^^^^^^
+      def visit_keyword_hash_node(node)
+        elements = visit_all(node.elements)
+
+        bounds(node.location)
+        on_bare_assoc_hash(elements)
+      end
+
+      # def foo(**bar); end
+      #         ^^^^^
+      #
+      # def foo(**); end
+      #         ^^
+      def visit_keyword_rest_parameter_node(node)
+        if node.name_loc.nil?
+          bounds(node.location)
+          on_kwrest_param(nil)
+        else
+          bounds(node.name_loc)
+          name = on_ident(node.name.to_s)
+
+          bounds(node.location)
+          on_kwrest_param(name)
+        end
+      end
+
+      # -> {}
+      def visit_lambda_node(node)
+        bounds(node.operator_loc)
+        on_tlambda(node.operator)
+
+        parameters =
+          if node.parameters.is_a?(BlockParametersNode)
+            # Ripper does not track block-locals within lambdas, so we skip
+            # directly to the parameters here.
+            params =
+              if node.parameters.parameters.nil?
+                bounds(node.location)
+                on_params(nil, nil, nil, nil, nil, nil, nil)
+              else
+                visit(node.parameters.parameters)
+              end
+
+            if node.parameters.opening_loc.nil?
+              params
+            else
+              bounds(node.parameters.opening_loc)
+              on_paren(params)
             end
-            method_args_val = on_method_add_arg(on_fcall(ident_val), args)
-            return on_method_add_block(method_args_val, block_val)
           else
-            if node.arguments.nil?
-              return on_command(ident_val, nil)
+            bounds(node.location)
+            on_params(nil, nil, nil, nil, nil, nil, nil)
+          end
+
+        braces = node.opening == "{"
+        if braces
+          bounds(node.opening_loc)
+          on_tlambeg(node.opening)
+        end
+
+        body =
+          case node.body
+          when nil
+            bounds(node.location)
+            stmts = on_stmts_add(on_stmts_new, on_void_stmt)
+
+            bounds(node.location)
+            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 = visit_statements_node_body(stmts)
+
+            bounds(node.body.location)
+            braces ? stmts : on_bodystmt(stmts, nil, nil, nil)
+          when BeginNode
+            visit_body_node(node.opening_loc, node.body)
+          else
+            raise
+          end
+
+        bounds(node.location)
+        on_lambda(parameters, body)
+      end
+
+      # foo
+      # ^^^
+      def visit_local_variable_read_node(node)
+        bounds(node.location)
+
+        if node.name == :"0it"
+          on_vcall(on_ident(node.slice))
+        else
+          on_var_ref(on_ident(node.slice))
+        end
+      end
+
+      # foo = 1
+      # ^^^^^^^
+      def visit_local_variable_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ident(node.name_loc.slice))
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_assign(target, value)
+      end
+
+      # foo += bar
+      # ^^^^^^^^^^
+      def visit_local_variable_operator_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ident(node.name_loc.slice))
+
+        bounds(node.operator_loc)
+        operator = on_op("#{node.operator}=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo &&= bar
+      # ^^^^^^^^^^^
+      def visit_local_variable_and_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ident(node.name_loc.slice))
+
+        bounds(node.operator_loc)
+        operator = on_op("&&=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo ||= bar
+      # ^^^^^^^^^^^
+      def visit_local_variable_or_write_node(node)
+        bounds(node.name_loc)
+        target = on_var_field(on_ident(node.name_loc.slice))
+
+        bounds(node.operator_loc)
+        operator = on_op("||=")
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_opassign(target, operator, value)
+      end
+
+      # foo, = bar
+      # ^^^
+      def visit_local_variable_target_node(node)
+        bounds(node.location)
+        on_var_field(on_ident(node.name.to_s))
+      end
+
+      # if /foo/ then end
+      #    ^^^^^
+      def visit_match_last_line_node(node)
+        bounds(node.opening_loc)
+        on_regexp_beg(node.opening)
+
+        bounds(node.content_loc)
+        tstring_content = on_tstring_content(node.content)
+
+        bounds(node.closing_loc)
+        closing = on_regexp_end(node.closing)
+
+        on_regexp_literal(on_regexp_add(on_regexp_new, tstring_content), closing)
+      end
+
+      # foo in bar
+      # ^^^^^^^^^^
+      def visit_match_predicate_node(node)
+        value = visit(node.value)
+        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
+
+        on_case(value, pattern)
+      end
+
+      # foo => bar
+      # ^^^^^^^^^^
+      def visit_match_required_node(node)
+        value = visit(node.value)
+        pattern = on_in(visit_pattern_node(node.pattern), nil, nil)
+
+        on_case(value, pattern)
+      end
+
+      # /(?<foo>foo)/ =~ bar
+      # ^^^^^^^^^^^^^^^^^^^^
+      def visit_match_write_node(node)
+        visit(node.call)
+      end
+
+      # 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."
+      end
+
+      # module Foo; end
+      # ^^^^^^^^^^^^^^^
+      def visit_module_node(node)
+        constant_path =
+          if node.constant_path.is_a?(ConstantReadNode)
+            bounds(node.constant_path.location)
+            on_const_ref(on_const(node.constant_path.name.to_s))
+          else
+            visit(node.constant_path)
+          end
+
+        bodystmt = visit_body_node(node.constant_path.location, node.body, true)
+
+        bounds(node.location)
+        on_module(constant_path, bodystmt)
+      end
+
+      # (foo, bar), bar = qux
+      # ^^^^^^^^^^
+      def visit_multi_target_node(node)
+        bounds(node.location)
+        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)
+
+        if node.lparen_loc.nil?
+          targets
+        else
+          bounds(node.lparen_loc)
+          on_mlhs_paren(targets)
+        end
+      end
+
+      # Visit the targets of a multi-target node.
+      private def visit_multi_target_node_targets(lefts, rest, rights, skippable)
+        if skippable && lefts.length == 1 && lefts.first.is_a?(MultiTargetNode) && rest.nil? && rights.empty?
+          return visit(lefts.first)
+        end
+
+        mlhs = on_mlhs_new
+
+        lefts.each do |left|
+          bounds(left.location)
+          mlhs = on_mlhs_add(mlhs, visit(left))
+        end
+
+        case rest
+        when nil
+          # do nothing
+        when ImplicitRestNode
+          # these do not get put into the generated tree
+          bounds(rest.location)
+          on_excessed_comma
+        else
+          bounds(rest.location)
+          mlhs = on_mlhs_add_star(mlhs, visit(rest))
+        end
+
+        if rights.any?
+          bounds(rights.first.location)
+          post = on_mlhs_new
+
+          rights.each do |right|
+            bounds(right.location)
+            post = on_mlhs_add(post, visit(right))
+          end
+
+          mlhs = on_mlhs_add_post(mlhs, post)
+        end
+
+        mlhs
+      end
+
+      # foo, bar = baz
+      # ^^^^^^^^^^^^^^
+      def visit_multi_write_node(node)
+        bounds(node.location)
+        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, true)
+
+        unless node.lparen_loc.nil?
+          bounds(node.lparen_loc)
+          targets = on_mlhs_paren(targets)
+        end
+
+        value = visit_write_value(node.value)
+
+        bounds(node.location)
+        on_massign(targets, value)
+      end
+
+      # next
+      # ^^^^
+      #
+      # next foo
+      # ^^^^^^^^
+      def visit_next_node(node)
+        if node.arguments.nil?
+          bounds(node.location)
+          on_next(on_args_new)
+        else
+          arguments = visit(node.arguments)
+
+          bounds(node.location)
+          on_next(arguments)
+        end
+      end
+
+      # nil
+      # ^^^
+      def visit_nil_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("nil"))
+      end
+
+      # def foo(**nil); end
+      #         ^^^^^
+      def visit_no_keywords_parameter_node(node)
+        bounds(node.location)
+        on_nokw_param(nil)
+
+        :nil
+      end
+
+      # -> { _1 + _2 }
+      # ^^^^^^^^^^^^^^
+      def visit_numbered_parameters_node(node)
+      end
+
+      # $1
+      # ^^
+      def visit_numbered_reference_read_node(node)
+        bounds(node.location)
+        on_backref(node.slice)
+      end
+
+      # def foo(bar: baz); end
+      #         ^^^^^^^^
+      def visit_optional_keyword_parameter_node(node)
+        bounds(node.name_loc)
+        name = on_label("#{node.name}:")
+        value = visit(node.value)
+
+        [name, value]
+      end
+
+      # def foo(bar = 1); end
+      #         ^^^^^^^
+      def visit_optional_parameter_node(node)
+        bounds(node.name_loc)
+        name = visit_token(node.name.to_s)
+        value = visit(node.value)
+
+        [name, value]
+      end
+
+      # a or b
+      # ^^^^^^
+      def visit_or_node(node)
+        left = visit(node.left)
+        right = visit(node.right)
+
+        bounds(node.location)
+        on_binary(left, node.operator.to_sym, right)
+      end
+
+      # def foo(bar, *baz); end
+      #         ^^^^^^^^^
+      def visit_parameters_node(node)
+        requireds = node.requireds.map { |required| required.is_a?(MultiTargetNode) ? visit_destructured_parameter_node(required) : visit(required) } if node.requireds.any?
+        optionals = visit_all(node.optionals) if node.optionals.any?
+        rest = visit(node.rest)
+        posts = node.posts.map { |post| post.is_a?(MultiTargetNode) ? visit_destructured_parameter_node(post) : visit(post) } if node.posts.any?
+        keywords = visit_all(node.keywords) if node.keywords.any?
+        keyword_rest = visit(node.keyword_rest)
+        block = visit(node.block)
+
+        bounds(node.location)
+        on_params(requireds, optionals, rest, posts, keywords, keyword_rest, block)
+      end
+
+      # Visit a destructured positional parameter node.
+      private def visit_destructured_parameter_node(node)
+        bounds(node.location)
+        targets = visit_multi_target_node_targets(node.lefts, node.rest, node.rights, false)
+
+        bounds(node.lparen_loc)
+        on_mlhs_paren(targets)
+      end
+
+      # ()
+      # ^^
+      #
+      # (1)
+      # ^^^
+      def visit_parentheses_node(node)
+        body =
+          if node.body.nil?
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.body)
+          end
+
+        bounds(node.location)
+        on_paren(body)
+      end
+
+      # foo => ^(bar)
+      #        ^^^^^^
+      def visit_pinned_expression_node(node)
+        expression = visit(node.expression)
+
+        bounds(node.location)
+        on_begin(expression)
+      end
+
+      # foo = 1 and bar => ^foo
+      #                    ^^^^
+      def visit_pinned_variable_node(node)
+        visit(node.variable)
+      end
+
+      # END {}
+      # ^^^^^^
+      def visit_post_execution_node(node)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        bounds(node.location)
+        on_END(statements)
+      end
+
+      # BEGIN {}
+      # ^^^^^^^^
+      def visit_pre_execution_node(node)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        bounds(node.location)
+        on_BEGIN(statements)
+      end
+
+      # The top-level program node.
+      def visit_program_node(node)
+        body = node.statements.body
+        body << nil if body.empty?
+        statements = visit_statements_node_body(body)
+
+        bounds(node.location)
+        on_program(statements)
+      end
+
+      # 0..5
+      # ^^^^
+      def visit_range_node(node)
+        left = visit(node.left)
+        right = visit(node.right)
+
+        bounds(node.location)
+        if node.exclude_end?
+          on_dot3(left, right)
+        else
+          on_dot2(left, right)
+        end
+      end
+
+      # 1r
+      # ^^
+      def visit_rational_node(node)
+        visit_number_node(node) { |text| on_rational(text) }
+      end
+
+      # redo
+      # ^^^^
+      def visit_redo_node(node)
+        bounds(node.location)
+        on_redo
+      end
+
+      # /foo/
+      # ^^^^^
+      def visit_regular_expression_node(node)
+        bounds(node.opening_loc)
+        on_regexp_beg(node.opening)
+
+        if node.content.empty?
+          bounds(node.closing_loc)
+          closing = on_regexp_end(node.closing)
+
+          on_regexp_literal(on_regexp_new, closing)
+        else
+          bounds(node.content_loc)
+          tstring_content = on_tstring_content(node.content)
+
+          bounds(node.closing_loc)
+          closing = on_regexp_end(node.closing)
+
+          on_regexp_literal(on_regexp_add(on_regexp_new, tstring_content), closing)
+        end
+      end
+
+      # def foo(bar:); end
+      #         ^^^^
+      def visit_required_keyword_parameter_node(node)
+        bounds(node.name_loc)
+        [on_label("#{node.name}:"), false]
+      end
+
+      # def foo(bar); end
+      #         ^^^
+      def visit_required_parameter_node(node)
+        bounds(node.location)
+        on_ident(node.name.to_s)
+      end
+
+      # foo rescue bar
+      # ^^^^^^^^^^^^^^
+      def visit_rescue_modifier_node(node)
+        expression = visit_write_value(node.expression)
+        rescue_expression = visit(node.rescue_expression)
+
+        bounds(node.location)
+        on_rescue_mod(expression, rescue_expression)
+      end
+
+      # begin; rescue; end
+      #        ^^^^^^^
+      def visit_rescue_node(node)
+        exceptions =
+          case node.exceptions.length
+          when 0
+            nil
+          when 1
+            if (exception = node.exceptions.first).is_a?(SplatNode)
+              bounds(exception.location)
+              on_mrhs_add_star(on_mrhs_new, visit(exception))
             else
-              args = on_args_add_block(visit_elements(node.arguments.arguments), false)
-              return on_command(ident_val, args)
+              [visit(node.exceptions.first)]
+            end
+          else
+            bounds(node.location)
+            length = node.exceptions.length
+
+            node.exceptions.each_with_index.inject(on_args_new) do |mrhs, (exception, index)|
+              arg = visit(exception)
+
+              bounds(exception.location)
+              mrhs = on_mrhs_new_from_args(mrhs) if index == length - 1
+
+              if exception.is_a?(SplatNode)
+                if index == length - 1
+                  on_mrhs_add_star(mrhs, arg)
+                else
+                  on_args_add_star(mrhs, arg)
+                end
+              else
+                if index == length - 1
+                  on_mrhs_add(mrhs, arg)
+                else
+                  on_args_add(mrhs, arg)
+                end
+              end
             end
           end
+
+        reference = visit(node.reference)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
+          else
+            visit(node.statements)
+          end
+
+        consequent = visit(node.consequent)
+
+        bounds(node.location)
+        on_rescue(exceptions, reference, statements, consequent)
+      end
+
+      # def foo(*bar); end
+      #         ^^^^
+      #
+      # def foo(*); end
+      #         ^
+      def visit_rest_parameter_node(node)
+        if node.name_loc.nil?
+          bounds(node.location)
+          on_rest_param(nil)
         else
-          operator = node.call_operator_loc.slice
-          if operator == "." || operator == "&."
-            left_val = visit(node.receiver)
+          bounds(node.name_loc)
+          on_rest_param(visit_token(node.name.to_s))
+        end
+      end
 
-            bounds(node.call_operator_loc)
-            operator_val = operator == "." ? on_period(node.call_operator) : on_op(node.call_operator)
+      # retry
+      # ^^^^^
+      def visit_retry_node(node)
+        bounds(node.location)
+        on_retry
+      end
 
-            bounds(node.message_loc)
-            right_val = on_ident(node.message)
+      # return
+      # ^^^^^^
+      #
+      # return 1
+      # ^^^^^^^^
+      def visit_return_node(node)
+        if node.arguments.nil?
+          bounds(node.location)
+          on_return0
+        else
+          arguments = visit(node.arguments)
 
-            call_val = on_call(left_val, operator_val, right_val)
+          bounds(node.location)
+          on_return(arguments)
+        end
+      end
 
-            if node.block
-              block_val = visit(node.block)
-              return on_method_add_block(call_val, block_val)
-            else
-              return call_val
+      # self
+      # ^^^^
+      def visit_self_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("self"))
+      end
+
+      # A shareable constant.
+      def visit_shareable_constant_node(node)
+        visit(node.write)
+      end
+
+      # class << self; end
+      # ^^^^^^^^^^^^^^^^^^
+      def visit_singleton_class_node(node)
+        expression = visit(node.expression)
+        bodystmt = visit_body_node(node.body&.location || node.end_keyword_loc, node.body)
+
+        bounds(node.location)
+        on_sclass(expression, bodystmt)
+      end
+
+      # __ENCODING__
+      # ^^^^^^^^^^^^
+      def visit_source_encoding_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("__ENCODING__"))
+      end
+
+      # __FILE__
+      # ^^^^^^^^
+      def visit_source_file_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("__FILE__"))
+      end
+
+      # __LINE__
+      # ^^^^^^^^
+      def visit_source_line_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("__LINE__"))
+      end
+
+      # foo(*bar)
+      #     ^^^^
+      #
+      # def foo((bar, *baz)); end
+      #               ^^^^
+      #
+      # def foo(*); bar(*); end
+      #                 ^
+      def visit_splat_node(node)
+        visit(node.expression)
+      end
+
+      # A list of statements.
+      def visit_statements_node(node)
+        bounds(node.location)
+        visit_statements_node_body(node.body)
+      end
+
+      # Visit the list of statements of a statements node. We support nil
+      # statements in the list. This would normally not be allowed by the
+      # structure of the prism parse tree, but we manually add them here so that
+      # we can mirror Ripper's void stmt.
+      private def visit_statements_node_body(body)
+        body.inject(on_stmts_new) do |stmts, stmt|
+          on_stmts_add(stmts, stmt.nil? ? on_void_stmt : visit(stmt))
+        end
+      end
+
+      # "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)
+
+          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))
+        end
+      end
+
+      # Ripper gives back the escaped string content but strips out the common
+      # leading whitespace. Prism gives back the unescaped string content and
+      # a location for the escaped string content. Unfortunately these don't
+      # work well together, so here we need to re-derive the common leading
+      # whitespace.
+      private def visit_heredoc_node_whitespace(parts)
+        common_whitespace = nil
+        dedent_next = true
+
+        parts.each do |part|
+          if part.is_a?(StringNode)
+            if dedent_next && !(content = part.content).chomp.empty?
+              common_whitespace = [
+                common_whitespace || Float::INFINITY,
+                content[/\A\s*/].each_char.inject(0) do |part_whitespace, char|
+                  char == "\t" ? ((part_whitespace / 8 + 1) * 8) : (part_whitespace + 1)
+                end
+              ].min
             end
+
+            dedent_next = true
           else
-            raise NotImplementedError, "operator other than . or &. for call: #{operator.inspect}"
+            dedent_next = false
           end
         end
+
+        common_whitespace || 0
       end
 
-      # Visit a list of elements, like the elements of an array or arguments.
-      def visit_elements(elements)
-        bounds(elements.first.location)
-        elements.inject(on_args_new) do |args, element|
-          on_args_add(args, visit(element))
+      # Visit a string that is expressed using a <<~ heredoc.
+      private def visit_heredoc_node(parts, base)
+        common_whitespace = visit_heredoc_node_whitespace(parts)
+
+        if common_whitespace == 0
+          bounds(parts.first.location)
+
+          string = []
+          result = base
+
+          parts.each do |part|
+            if part.is_a?(StringNode)
+              if string.empty?
+                string = [part]
+              else
+                string << part
+              end
+            else
+              unless string.empty?
+                bounds(string[0].location)
+                result = yield result, on_tstring_content(string.map(&:content).join)
+                string = []
+              end
+
+              result = yield result, visit(part)
+            end
+          end
+
+          unless string.empty?
+            bounds(string[0].location)
+            result = yield result, on_tstring_content(string.map(&:content).join)
+          end
+
+          result
+        else
+          bounds(parts.first.location)
+          result =
+            parts.inject(base) do |string_content, part|
+              yield string_content, visit_string_content(part)
+            end
+
+          bounds(parts.first.location)
+          on_heredoc_dedent(result, common_whitespace)
         end
       end
 
-      # Visit an InterpolatedStringNode or an InterpolatedSymbolNode node.
-      def visit_enumerated_node(node)
-        parts = node.parts.map do |part|
-          case part
-          when StringNode
-            bounds(part.content_loc)
-            on_tstring_content(part.content)
-          when EmbeddedStatementsNode
-            on_string_embexpr(visit(part))
-          else
-            raise NotImplementedError, "Unexpected node type in visit_enumerated_node"
+      # 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
+      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
+      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))
+
+        if !node.lparen_loc.nil?
+          bounds(node.lparen_loc)
+          arguments = on_arg_paren(arguments)
         end
 
-        parts.inject(on_string_content) do |items, item|
-          on_string_add(items, item)
+        bounds(node.location)
+        call = on_super(arguments)
+
+        if block.nil?
+          call
+        else
+          bounds(node.block.location)
+          on_method_add_block(call, block)
         end
       end
 
-      # Visit an operation-and-assign node, such as +=.
-      def visit_binary_op_assign(node, operator: node.operator)
-        bounds(node.name_loc)
-        ident_val = on_ident(node.name.to_s)
+      # :foo
+      # ^^^^
+      def visit_symbol_node(node)
+        if (opening = node.opening)&.match?(/^%s|['"]:?$/)
+          bounds(node.value_loc)
+          content = on_string_content
 
-        bounds(node.operator_loc)
-        op_val = on_op(operator)
+          if !(value = node.value).empty?
+            content = on_string_add(content, on_tstring_content(value))
+          end
 
-        on_opassign(on_var_field(ident_val), op_val, visit(node.value))
+          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)))
+        end
       end
 
-      # In Prism this is a CallNode with :[] as the operator.
-      # In Ripper it's an :aref.
-      def visit_aref_node(node)
-        first_arg_val = visit(node.arguments.arguments[0])
-        args_val = on_args_add_block(on_args_add(on_args_new, first_arg_val), false)
-        on_aref(visit(node.receiver), args_val)
+      # true
+      # ^^^^
+      def visit_true_node(node)
+        bounds(node.location)
+        on_var_ref(on_kw("true"))
       end
 
-      # In Prism this is a CallNode with :[]= as the operator.
-      # In Ripper it's an :aref_field.
-      def visit_aref_field_node(node)
-        first_arg_val = visit(node.arguments.arguments[0])
-        args_val = on_args_add_block(on_args_add(on_args_new, first_arg_val), false)
-        assign_val = visit(node.arguments.arguments[1])
-        on_assign(on_aref_field(visit(node.receiver), args_val), assign_val)
+      # undef foo
+      # ^^^^^^^^^
+      def visit_undef_node(node)
+        names = visit_all(node.names)
+
+        bounds(node.location)
+        on_undef(names)
       end
 
-      # In an alias statement Ripper will emit @kw instead of @ident if the object
-      # being aliased is a Ruby keyword. For instance, in the line "alias :foo :if",
-      # the :if is treated as a lexer keyword. So we need to know what symbols are
-      # also keywords.
-      RUBY_KEYWORDS = [
-        "alias",
-        "and",
-        "begin",
-        "BEGIN",
-        "break",
-        "case",
-        "class",
-        "def",
-        "defined?",
-        "do",
-        "else",
-        "elsif",
-        "end",
-        "END",
-        "ensure",
-        "false",
-        "for",
-        "if",
-        "in",
-        "module",
-        "next",
-        "nil",
-        "not",
-        "or",
-        "redo",
-        "rescue",
-        "retry",
-        "return",
-        "self",
-        "super",
-        "then",
-        "true",
-        "undef",
-        "unless",
-        "until",
-        "when",
-        "while",
-        "yield",
-        "__ENCODING__",
-        "__FILE__",
-        "__LINE__",
-      ]
+      # unless foo; bar end
+      # ^^^^^^^^^^^^^^^^^^^
+      #
+      # bar unless foo
+      # ^^^^^^^^^^^^^^
+      def visit_unless_node(node)
+        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          predicate = visit(node.predicate)
+          statements =
+            if node.statements.nil?
+              bounds(node.location)
+              on_stmts_add(on_stmts_new, on_void_stmt)
+            else
+              visit(node.statements)
+            end
+          consequent = visit(node.consequent)
 
-      # Ripper has several methods of emitting a symbol literal. Inside an alias
-      # sometimes it suppresses the [:symbol] wrapper around ident. If the symbol
-      # is also the name of a keyword (e.g. :if) it will emit a :@kw wrapper, not
-      # an :@ident wrapper, with similar treatment for constants and operators.
-      def visit_symbol_literal_node(node, no_symbol_wrapper: false)
-        if (opening = node.opening) && (['"', "'"].include?(opening[-1]) || opening.start_with?("%s"))
-          bounds(node.value_loc)
-          str_val = node.value.to_s
-          if str_val == ""
-            return on_dyna_symbol(on_string_content)
+          bounds(node.location)
+          on_unless(predicate, statements, consequent)
+        else
+          statements = visit(node.statements.body.first)
+          predicate = visit(node.predicate)
+
+          bounds(node.location)
+          on_unless_mod(predicate, statements)
+        end
+      end
+
+      # until foo; bar end
+      # ^^^^^^^^^^^^^^^^^
+      #
+      # bar until foo
+      # ^^^^^^^^^^^^^
+      def visit_until_node(node)
+        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          predicate = visit(node.predicate)
+          statements =
+            if node.statements.nil?
+              bounds(node.location)
+              on_stmts_add(on_stmts_new, on_void_stmt)
+            else
+              visit(node.statements)
+            end
+
+          bounds(node.location)
+          on_until(predicate, statements)
+        else
+          statements = visit(node.statements.body.first)
+          predicate = visit(node.predicate)
+
+          bounds(node.location)
+          on_until_mod(predicate, statements)
+        end
+      end
+
+      # case foo; when bar; end
+      #           ^^^^^^^^^^^^^
+      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 consequent. Instead, we'll return
+        # the component parts and let the parent node handle it.
+        conditions = visit_arguments(node.conditions)
+        statements =
+          if node.statements.nil?
+            bounds(node.location)
+            on_stmts_add(on_stmts_new, on_void_stmt)
           else
-            tstring_val = on_tstring_content(str_val)
-            return on_dyna_symbol(on_string_add(on_string_content, tstring_val))
+            visit(node.statements)
+          end
+
+        [conditions, statements]
+      end
+
+      # while foo; bar end
+      # ^^^^^^^^^^^^^^^^^^
+      #
+      # bar while foo
+      # ^^^^^^^^^^^^^
+      def visit_while_node(node)
+        if node.statements.nil? || (node.predicate.location.start_offset < node.statements.location.start_offset)
+          predicate = visit(node.predicate)
+          statements =
+            if node.statements.nil?
+              bounds(node.location)
+              on_stmts_add(on_stmts_new, on_void_stmt)
+            else
+              visit(node.statements)
+            end
+
+          bounds(node.location)
+          on_while(predicate, statements)
+        else
+          statements = visit(node.statements.body.first)
+          predicate = visit(node.predicate)
+
+          bounds(node.location)
+          on_while_mod(predicate, statements)
+        end
+      end
+
+      # `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)
+
+          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))
+        end
+      end
+
+      # yield
+      # ^^^^^
+      #
+      # yield 1
+      # ^^^^^^^
+      def visit_yield_node(node)
+        if node.arguments.nil? && node.lparen_loc.nil?
+          bounds(node.location)
+          on_yield0
+        else
+          arguments =
+            if node.arguments.nil?
+              bounds(node.location)
+              on_args_new
+            else
+              visit(node.arguments)
+            end
+
+          unless node.lparen_loc.nil?
+            bounds(node.lparen_loc)
+            arguments = on_paren(arguments)
           end
+
+          bounds(node.location)
+          on_yield(arguments)
         end
+      end
+
+      private
+
+      # Lazily initialize the parse result.
+      def result
+        @result ||= Prism.parse(source)
+      end
+
+      ##########################################################################
+      # Helpers
+      ##########################################################################
+
+      # Returns true if there is a comma between the two locations.
+      def trailing_comma?(left, right)
+        source.byteslice(left.end_offset...right.start_offset).include?(",")
+      end
+
+      # Returns true if there is a semicolon between the two locations.
+      def void_stmt?(left, right, allow_newline)
+        pattern = allow_newline ? /[;\n]/ : /;/
+        source.byteslice(left.end_offset...right.start_offset).match?(pattern)
+      end
 
-        bounds(node.value_loc)
-        node_name = node.value.to_s
-        if RUBY_KEYWORDS.include?(node_name)
-          token_val = on_kw(node_name)
-        elsif node_name.length == 0
-          raise NotImplementedError
-        elsif /[[:upper:]]/.match(node_name[0])
-          token_val = on_const(node_name)
-        elsif /[[:punct:]]/.match(node_name[0])
-          token_val = on_op(node_name)
+      # 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 "."
+          on_period(token)
+        when "`"
+          on_backtick(token)
+        when *(allow_keywords ? KEYWORDS : [])
+          on_kw(token)
+        when /^_/
+          on_ident(token)
+        when /^[[:upper:]]\w*$/
+          on_const(token)
+        when /^@@/
+          on_cvar(token)
+        when /^@/
+          on_ivar(token)
+        when /^\$/
+          on_gvar(token)
+        when /^[[:punct:]]/
+          on_op(token)
         else
-          token_val = on_ident(node_name)
+          on_ident(token)
         end
-        sym_val = no_symbol_wrapper ? token_val : on_symbol(token_val)
-        on_symbol_literal(sym_val)
       end
 
       # Visit a node that represents a number. We need to explicitly handle the
       # unary - operator.
-      def visit_number(node)
+      def visit_number_node(node)
         slice = node.slice
         location = node.location
 
         if slice[0] == "-"
-          bounds_values(location.start_line, location.start_column + 1)
+          bounds(location.copy(start_offset: location.start_offset + 1))
           value = yield slice[1..-1]
 
           bounds(node.location)
-          on_unary(visit_unary_operator(:-@), value)
+          on_unary(:-@, value)
         else
           bounds(location)
           yield slice
         end
       end
 
-      if RUBY_ENGINE == "jruby" && Gem::Version.new(JRUBY_VERSION) < Gem::Version.new("9.4.6.0")
-        # JRuby before 9.4.6.0 uses :- for unary minus instead of :-@
-        def visit_unary_operator(value)
-          value == :-@ ? :- : value
-        end
-      else
-        # For most Rubies and JRuby after 9.4.6.0 this is a no-op.
-        def visit_unary_operator(value)
-          value
-        end
-      end
-
-      if RUBY_ENGINE == "jruby"
-        # For JRuby, "no block" in an on_block_var is nil
-        def no_block_value
-          nil
-        end
-      else
-        # For CRuby et al, "no block" in an on_block_var is false
-        def no_block_value
-          false
+      # Visit a node that represents a write value. This is used to handle the
+      # special case of an implicit array that is generated without brackets.
+      def visit_write_value(node)
+        if node.is_a?(ArrayNode) && node.opening_loc.nil?
+          elements = node.elements
+          length = elements.length
+
+          bounds(elements.first.location)
+          elements.each_with_index.inject((elements.first.is_a?(SplatNode) && length == 1) ? on_mrhs_new : on_args_new) do |args, (element, index)|
+            arg = visit(element)
+            bounds(element.location)
+
+            if index == length - 1
+              if element.is_a?(SplatNode)
+                mrhs = index == 0 ? args : on_mrhs_new_from_args(args)
+                on_mrhs_add_star(mrhs, arg)
+              else
+                on_mrhs_add(on_mrhs_new_from_args(args), arg)
+              end
+            else
+              case element
+              when BlockArgumentNode
+                on_args_add_block(args, arg)
+              when SplatNode
+                on_args_add_star(args, arg)
+              else
+                on_args_add(args, arg)
+              end
+            end
+          end
+        else
+          visit(node)
         end
       end
 
-      # Visit a binary operator node like an AndNode or OrNode
-      def visit_binary_operator(node)
-        left_val = visit(node.left)
-        right_val = visit(node.right)
-        on_binary(left_val, node.operator.to_sym, right_val)
-      end
-
       # This method is responsible for updating lineno and column information
       # to reflect the current node.
       #
@@ -665,31 +3375,71 @@ module Prism
         @column = location.start_column
       end
 
-      # If we need to do something unusual, we can directly update the line number
-      # and column to reflect the current node.
-      def bounds_values(lineno, column)
-        @lineno = lineno
-        @column = column
+      ##########################################################################
+      # 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
+      # :startdoc:
+
+      #
+      # Parser Events
+      #
+
+      PARSER_EVENT_TABLE.each do |id, arity|
+        alias_method "on_#{id}", "_dispatch_#{arity}"
       end
 
-      # Lazily initialize the parse result.
-      def result
-        @result ||= Prism.parse(source)
+      # This method is called when weak warning is produced by the parser.
+      # +fmt+ and +args+ is printf style.
+      def warn(fmt, *args)
+      end
+
+      # This method is called when strong warning is produced by the parser.
+      # +fmt+ and +args+ is printf style.
+      def warning(fmt, *args)
+      end
+
+      # This method is called when the parser found syntax error.
+      def compile_error(msg)
       end
 
-      def _dispatch0; end # :nodoc:
-      def _dispatch1(_); end # :nodoc:
-      def _dispatch2(_, _); end # :nodoc:
-      def _dispatch3(_, _, _); end # :nodoc:
-      def _dispatch4(_, _, _, _); end # :nodoc:
-      def _dispatch5(_, _, _, _, _); end # :nodoc:
-      def _dispatch7(_, _, _, _, _, _, _); end # :nodoc:
+      #
+      # Scanner Events
+      #
+
+      SCANNER_EVENTS.each do |id|
+        alias_method "on_#{id}", :_dispatch_1
+      end
 
-      alias_method :on_parse_error, :_dispatch1
-      alias_method :on_magic_comment, :_dispatch2
+      # This method is provided by the Ripper C extension. It is called when a
+      # string needs to be dedented because of a tilde heredoc. It is expected
+      # that it will modify the string in place and return the number of bytes
+      # that were removed.
+      def dedent_string(string, width)
+        whitespace = 0
+        cursor = 0
+
+        while cursor < string.length && string[cursor].match?(/\s/) && whitespace < width
+          if string[cursor] == "\t"
+            whitespace = ((whitespace / 8 + 1) * 8)
+            break if whitespace > width
+          else
+            whitespace += 1
+          end
+
+          cursor += 1
+        end
 
-      (::Ripper::SCANNER_EVENT_TABLE.merge(::Ripper::PARSER_EVENT_TABLE)).each do |event, arity|
-        alias_method :"on_#{event}", :"_dispatch#{arity}"
+        string.replace(string[cursor..])
+        cursor
       end
     end
   end