compiler.rb

# frozen_string_literal: true

module Prism
  class ParserCompiler < Compiler
    attr_reader :parser, :builder, :source_buffer, :offset_cache
    attr_reader :locals, :in_destructure, :in_pattern

    def initialize(parser, offset_cache, locals: nil, in_destructure: false, in_pattern: false)
      @parser = parser
      @builder = parser.builder
      @source_buffer = parser.source_buffer
      @offset_cache = offset_cache

      @locals = locals
      @in_destructure = in_destructure
      @in_pattern = in_pattern
    end

    # alias foo bar
    # ^^^^^^^^^^^^^
    def visit_alias_method_node(node)
      builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
    end

    # alias $foo $bar
    # ^^^^^^^^^^^^^^^
    def visit_alias_global_variable_node(node)
      builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
    end

    # foo => bar | baz
    #        ^^^^^^^^^
    def visit_alternation_pattern_node(node)
      builder.match_alt(visit(node.left), token(node.operator_loc), visit(node.right))
    end

    # a and b
    # ^^^^^^^
    def visit_and_node(node)
      builder.logical_op(:and, visit(node.left), token(node.operator_loc), visit(node.right))
    end

    # []
    # ^^
    def visit_array_node(node)
      builder.array(token(node.opening_loc), visit_all(node.elements), token(node.closing_loc))
    end

    # foo => [bar]
    #        ^^^^^
    def visit_array_pattern_node(node)
      if node.constant
        builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(nil, visit_all([*node.requireds, *node.rest, *node.posts]), nil), token(node.closing_loc))
      else
        builder.array_pattern(token(node.opening_loc), visit_all([*node.requireds, *node.rest, *node.posts]), token(node.closing_loc))
      end
    end

    # foo(bar)
    #     ^^^
    def visit_arguments_node(node)
      visit_all(node.arguments)
    end

    # { a: 1 }
    #   ^^^^
    def visit_assoc_node(node)
      if node.value.is_a?(ImplicitNode)
        builder.pair_label([node.key.slice.chomp(":"), srange(node.key.location)])
      elsif in_pattern && node.value.nil?
        if node.key.is_a?(SymbolNode)
          builder.match_hash_var([node.key.unescaped, srange(node.key.location)])
        else
          builder.match_hash_var_from_str(token(node.key.opening_loc), visit_all(node.key.parts), token(node.key.closing_loc))
        end
      elsif node.operator_loc
        builder.pair(visit(node.key), token(node.operator_loc), visit(node.value))
      elsif node.key.is_a?(SymbolNode) && node.key.opening_loc.nil?
        builder.pair_keyword([node.key.unescaped, srange(node.key.location)], visit(node.value))
      else
        parts =
          if node.key.is_a?(SymbolNode)
            [builder.string_internal([node.key.unescaped, srange(node.key.value_loc)])]
          else
            visit_all(node.key.parts)
          end

        builder.pair_quoted(token(node.key.opening_loc), parts, token(node.key.closing_loc), visit(node.value))
      end
    end

    # def foo(**); bar(**); end
    #                  ^^
    #
    # { **foo }
    #   ^^^^^
    def visit_assoc_splat_node(node)
      if node.value.nil? && locals.include?(:**)
        builder.forwarded_kwrestarg(token(node.operator_loc))
      else
        builder.kwsplat(token(node.operator_loc), visit(node.value))
      end
    end

    # $+
    # ^^
    def visit_back_reference_read_node(node)
      builder.back_ref(token(node.location))
    end

    # begin end
    # ^^^^^^^^^
    def visit_begin_node(node)
      rescue_bodies = []

      if (rescue_clause = node.rescue_clause)
        begin
          find_start_offset = (rescue_clause.reference&.location || rescue_clause.exceptions.last&.location || rescue_clause.keyword_loc).end_offset
          find_end_offset = (rescue_clause.statements&.location&.start_offset || rescue_clause.consequent&.location&.start_offset || (find_start_offset + 1))

          rescue_bodies << builder.rescue_body(
            token(rescue_clause.keyword_loc),
            rescue_clause.exceptions.any? ? builder.array(nil, visit_all(rescue_clause.exceptions), nil) : nil,
            token(rescue_clause.operator_loc),
            visit(rescue_clause.reference),
            srange_find(find_start_offset, find_end_offset, [";"]),
            visit(rescue_clause.statements)
          )
        end until (rescue_clause = rescue_clause.consequent).nil?
      end

      begin_body =
        builder.begin_body(
          visit(node.statements),
          rescue_bodies,
          token(node.else_clause&.else_keyword_loc),
          visit(node.else_clause),
          token(node.ensure_clause&.ensure_keyword_loc),
          visit(node.ensure_clause&.statements)
        )

      if node.begin_keyword_loc
        builder.begin_keyword(token(node.begin_keyword_loc), begin_body, token(node.end_keyword_loc))
      else
        begin_body
      end
    end

    # foo(&bar)
    #     ^^^^
    def visit_block_argument_node(node)
      builder.block_pass(token(node.operator_loc), visit(node.expression))
    end

    # foo { |; bar| }
    #          ^^^
    def visit_block_local_variable_node(node)
      builder.shadowarg(token(node.location))
    end

    # A block on a keyword or method call.
    def visit_block_node(node)
      raise "Cannot directly compile block nodes"
    end

    # def foo(&bar); end
    #         ^^^^
    def visit_block_parameter_node(node)
      builder.blockarg(token(node.operator_loc), token(node.name_loc))
    end

    # A block's parameters.
    def visit_block_parameters_node(node)
      [*visit(node.parameters)].concat(visit_all(node.locals))
    end

    # break
    # ^^^^^
    #
    # break foo
    # ^^^^^^^^^
    def visit_break_node(node)
      builder.keyword_cmd(:break, token(node.keyword_loc), nil, visit(node.arguments) || [], nil)
    end

    # foo
    # ^^^
    #
    # foo.bar
    # ^^^^^^^
    #
    # foo.bar() {}
    # ^^^^^^^^^^^^
    def visit_call_node(node)
      name = node.name
      arguments = node.arguments&.arguments || []
      block = node.block

      if block.is_a?(BlockArgumentNode)
        arguments = [*arguments, block]
        block = nil
      end

      visit_block(
        if name == :!
          builder.not_op(
            token(node.message_loc),
            token(node.opening_loc),
            visit(node.receiver),
            token(node.closing_loc)
          )
        elsif name == :[]
          builder.index(
            visit(node.receiver),
            token(node.opening_loc),
            visit_all(arguments),
            token(node.closing_loc)
          )
        elsif name == :[]= && node.message != "[]=" && node.arguments && block.nil?
          builder.assign(
            builder.index_asgn(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(node.arguments.arguments[...-1]),
              token(node.closing_loc),
            ),
            srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, ["="]),
            visit(node.arguments.arguments.last)
          )
        else
          message_loc = node.message_loc
          call_operator_loc = node.call_operator_loc
          call_operator = [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)] if call_operator_loc

          if name.end_with?("=") && !message_loc.slice.end_with?("=") && node.arguments && block.nil?
            builder.assign(
              builder.attr_asgn(visit(node.receiver), call_operator, token(message_loc)),
              srange_find(message_loc.end_offset, node.arguments.location.start_offset, ["="]),
              visit(node.arguments.arguments.last)
            )
          else
            builder.call_method(
              visit(node.receiver),
              call_operator,
              message_loc ? [node.name, srange(message_loc)] : nil,
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc)
            )
          end
        end,
        block
      )
    end

    # foo.bar += baz
    # ^^^^^^^^^^^^^^^
    def visit_call_operator_write_node(node)
      call_operator_loc = node.call_operator_loc

      builder.op_assign(
        builder.call_method(
          visit(node.receiver),
          call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
          node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
          nil,
          [],
          nil
        ),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # foo.bar &&= baz
    # ^^^^^^^^^^^^^^^
    alias visit_call_and_write_node visit_call_operator_write_node

    # foo.bar ||= baz
    # ^^^^^^^^^^^^^^^
    alias visit_call_or_write_node visit_call_operator_write_node

    # foo.bar, = 1
    # ^^^^^^^
    def visit_call_target_node(node)
      call_operator_loc = node.call_operator_loc

      builder.attr_asgn(
        visit(node.receiver),
        call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
        token(node.message_loc)
      )
    end

    # foo => bar => baz
    #        ^^^^^^^^^^
    def visit_capture_pattern_node(node)
      builder.match_as(visit(node.value), token(node.operator_loc), visit(node.target))
    end

    # case foo; when bar; end
    # ^^^^^^^^^^^^^^^^^^^^^^^
    def visit_case_node(node)
      builder.case(
        token(node.case_keyword_loc),
        visit(node.predicate),
        visit_all(node.conditions),
        token(node.consequent&.else_keyword_loc),
        visit(node.consequent),
        token(node.end_keyword_loc)
      )
    end

    # case foo; in bar; end
    # ^^^^^^^^^^^^^^^^^^^^^
    def visit_case_match_node(node)
      builder.case_match(
        token(node.case_keyword_loc),
        visit(node.predicate),
        visit_all(node.conditions),
        token(node.consequent&.else_keyword_loc),
        visit(node.consequent),
        token(node.end_keyword_loc)
      )
    end

    # class Foo; end
    # ^^^^^^^^^^^^^^
    def visit_class_node(node)
      builder.def_class(
        token(node.class_keyword_loc),
        visit(node.constant_path),
        token(node.inheritance_operator_loc),
        visit(node.superclass),
        node.body&.accept(copy_compiler(locals: node.locals)),
        token(node.end_keyword_loc)
      )
    end

    # @@foo
    # ^^^^^
    def visit_class_variable_read_node(node)
      builder.cvar(token(node.location))
    end

    # @@foo = 1
    # ^^^^^^^^^
    #
    # @@foo, @@bar = 1
    # ^^^^^  ^^^^^
    def visit_class_variable_write_node(node)
      builder.assign(
        builder.assignable(builder.cvar(token(node.name_loc))),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # @@foo += bar
    # ^^^^^^^^^^^^
    def visit_class_variable_operator_write_node(node)
      builder.op_assign(
        builder.assignable(builder.cvar(token(node.name_loc))),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # @@foo &&= bar
    # ^^^^^^^^^^^^^
    alias visit_class_variable_and_write_node visit_class_variable_operator_write_node

    # @@foo ||= bar
    # ^^^^^^^^^^^^^
    alias visit_class_variable_or_write_node visit_class_variable_operator_write_node

    # @@foo, = bar
    # ^^^^^
    def visit_class_variable_target_node(node)
      builder.assignable(builder.cvar(token(node.location)))
    end

    # Foo
    # ^^^
    def visit_constant_read_node(node)
      builder.const([node.name, srange(node.location)])
    end

    # Foo = 1
    # ^^^^^^^
    #
    # Foo, Bar = 1
    # ^^^  ^^^
    def visit_constant_write_node(node)
      builder.assign(builder.assignable(builder.const([node.name, srange(node.name_loc)])), token(node.operator_loc), visit(node.value))
    end

    # Foo += bar
    # ^^^^^^^^^^^
    def visit_constant_operator_write_node(node)
      builder.op_assign(
        builder.assignable(builder.const([node.name, srange(node.name_loc)])),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # Foo &&= bar
    # ^^^^^^^^^^^^
    alias visit_constant_and_write_node visit_constant_operator_write_node

    # Foo ||= bar
    # ^^^^^^^^^^^^
    alias visit_constant_or_write_node visit_constant_operator_write_node

    # Foo, = bar
    # ^^^
    def visit_constant_target_node(node)
      builder.assignable(builder.const([node.name, srange(node.location)]))
    end

    # Foo::Bar
    # ^^^^^^^^
    def visit_constant_path_node(node)
      if node.parent.nil?
        builder.const_global(
          token(node.delimiter_loc),
          [node.child.name, srange(node.child.location)]
        )
      else
        builder.const_fetch(
          visit(node.parent),
          token(node.delimiter_loc),
          [node.child.name, srange(node.child.location)]
        )
      end
    end

    # Foo::Bar = 1
    # ^^^^^^^^^^^^
    #
    # Foo::Foo, Bar::Bar = 1
    # ^^^^^^^^  ^^^^^^^^
    def visit_constant_path_write_node(node)
      builder.assign(
        builder.assignable(visit(node.target)),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # Foo::Bar += baz
    # ^^^^^^^^^^^^^^^
    def visit_constant_path_operator_write_node(node)
      builder.op_assign(
        builder.assignable(visit(node.target)),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # Foo::Bar &&= baz
    # ^^^^^^^^^^^^^^^^
    alias visit_constant_path_and_write_node visit_constant_path_operator_write_node

    # Foo::Bar ||= baz
    # ^^^^^^^^^^^^^^^^
    alias visit_constant_path_or_write_node visit_constant_path_operator_write_node

    # Foo::Bar, = baz
    # ^^^^^^^^
    def visit_constant_path_target_node(node)
      builder.assignable(visit_constant_path_node(node))
    end

    # def foo; end
    # ^^^^^^^^^^^^
    #
    # def self.foo; end
    # ^^^^^^^^^^^^^^^^^
    def visit_def_node(node)
      if node.equal_loc
        if node.receiver
          builder.def_endless_singleton(
            token(node.def_keyword_loc),
            visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
            token(node.operator_loc),
            token(node.name_loc),
            builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
            token(node.equal_loc),
            node.body&.accept(copy_compiler(locals: node.locals))
          )
        else
          builder.def_endless_method(
            token(node.def_keyword_loc),
            token(node.name_loc),
            builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
            token(node.equal_loc),
            node.body&.accept(copy_compiler(locals: node.locals))
          )
        end
      elsif node.receiver
        builder.def_singleton(
          token(node.def_keyword_loc),
          visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
          token(node.operator_loc),
          token(node.name_loc),
          builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
          node.body&.accept(copy_compiler(locals: node.locals)),
          token(node.end_keyword_loc)
        )
      else
        builder.def_method(
          token(node.def_keyword_loc),
          token(node.name_loc),
          builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
          node.body&.accept(copy_compiler(locals: node.locals)),
          token(node.end_keyword_loc)
        )
      end
    end

    # defined? a
    # ^^^^^^^^^^
    #
    # defined?(a)
    # ^^^^^^^^^^^
    def visit_defined_node(node)
      builder.keyword_cmd(
        :defined?,
        token(node.keyword_loc),
        token(node.lparen_loc),
        [visit(node.value)],
        token(node.rparen_loc)
      )
    end

    # if foo then bar else baz end
    #                 ^^^^^^^^^^^^
    def visit_else_node(node)
      visit(node.statements)
    end

    # "foo #{bar}"
    #      ^^^^^^
    def visit_embedded_statements_node(node)
      builder.begin(
        token(node.opening_loc),
        visit(node.statements),
        token(node.closing_loc)
      )
    end

    # "foo #@bar"
    #      ^^^^^
    def visit_embedded_variable_node(node)
      visit(node.variable)
    end

    # begin; foo; ensure; bar; end
    #             ^^^^^^^^^^^^
    def visit_ensure_node(node)
      raise "Cannot directly compile ensure nodes"
    end

    # false
    # ^^^^^
    def visit_false_node(node)
      builder.false(token(node.location))
    end

    # foo => [*, bar, *]
    #        ^^^^^^^^^^^
    def visit_find_pattern_node(node)
      if node.constant
        builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.find_pattern(nil, visit_all([node.left, *node.requireds, node.right]), nil), token(node.closing_loc))
      else
        builder.find_pattern(token(node.opening_loc), visit_all([node.left, *node.requireds, node.right]), token(node.closing_loc))
      end
    end

    # 1.0
    # ^^^
    def visit_float_node(node)
      visit_numeric(node, builder.float([node.value, srange(node.location)]))
    end

    # for foo in bar do end
    # ^^^^^^^^^^^^^^^^^^^^^
    def visit_for_node(node)
      builder.for(
        token(node.for_keyword_loc),
        visit(node.index),
        token(node.in_keyword_loc),
        visit(node.collection),
        if node.do_keyword_loc
          token(node.do_keyword_loc)
        else
          srange_find(node.collection.location.end_offset, (node.statements&.location || node.end_keyword_loc).start_offset, [";"])
        end,
        visit(node.statements),
        token(node.end_keyword_loc)
      )
    end

    # def foo(...); bar(...); end
    #                   ^^^
    def visit_forwarding_arguments_node(node)
      builder.forwarded_args(token(node.location))
    end

    # def foo(...); end
    #         ^^^
    def visit_forwarding_parameter_node(node)
      builder.forward_arg(token(node.location))
    end

    # super
    # ^^^^^
    #
    # super {}
    # ^^^^^^^^
    def visit_forwarding_super_node(node)
      visit_block(
        builder.keyword_cmd(
          :zsuper,
          ["super", srange_offsets(node.location.start_offset, node.location.start_offset + 5)]
        ),
        node.block
      )
    end

    # $foo
    # ^^^^
    def visit_global_variable_read_node(node)
      builder.gvar(token(node.location))
    end

    # $foo = 1
    # ^^^^^^^^
    #
    # $foo, $bar = 1
    # ^^^^  ^^^^
    def visit_global_variable_write_node(node)
      builder.assign(
        builder.assignable(builder.gvar(token(node.name_loc))),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # $foo += bar
    # ^^^^^^^^^^^
    def visit_global_variable_operator_write_node(node)
      builder.op_assign(
        builder.assignable(builder.gvar(token(node.name_loc))),
        [node.operator, srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # $foo &&= bar
    # ^^^^^^^^^^^^
    alias visit_global_variable_and_write_node visit_global_variable_operator_write_node

    # $foo ||= bar
    # ^^^^^^^^^^^^
    alias visit_global_variable_or_write_node visit_global_variable_operator_write_node

    # $foo, = bar
    # ^^^^
    def visit_global_variable_target_node(node)
      builder.assignable(builder.gvar([node.slice, srange(node.location)]))
    end

    # {}
    # ^^
    def visit_hash_node(node)
      builder.associate(
        token(node.opening_loc),
        visit_all(node.elements),
        token(node.closing_loc)
      )
    end

    # foo => {}
    #        ^^
    def visit_hash_pattern_node(node)
      if node.constant
        builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.hash_pattern(nil, visit_all(node.elements), nil), token(node.closing_loc))
      else
        builder.hash_pattern(token(node.opening_loc), visit_all(node.elements), token(node.closing_loc))
      end
    end

    # if foo then bar end
    # ^^^^^^^^^^^^^^^^^^^
    #
    # bar if foo
    # ^^^^^^^^^^
    #
    # foo ? bar : baz
    # ^^^^^^^^^^^^^^^
    def visit_if_node(node)
      if !node.if_keyword_loc
        builder.ternary(
          visit(node.predicate),
          token(node.then_keyword_loc),
          visit(node.statements),
          token(node.consequent.else_keyword_loc),
          visit(node.consequent)
        )
      elsif node.if_keyword_loc.start_offset == node.location.start_offset
        builder.condition(
          token(node.if_keyword_loc),
          visit(node.predicate),
          if node.then_keyword_loc
            token(node.then_keyword_loc)
          else
            srange_find(node.predicate.location.end_offset, (node.statements&.location || node.consequent&.location || node.end_keyword_loc).start_offset, [";"])
          end,
          visit(node.statements),
          case node.consequent
          when IfNode
            token(node.consequent.if_keyword_loc)
          when ElseNode
            token(node.consequent.else_keyword_loc)
          end,
          visit(node.consequent),
          if node.if_keyword != "elsif"
            token(node.end_keyword_loc)
          end
        )
      else
        builder.condition_mod(
          visit(node.statements),
          visit(node.consequent),
          token(node.if_keyword_loc),
          visit(node.predicate)
        )
      end
    end

    # 1i
    def visit_imaginary_node(node)
      visit_numeric(node, builder.complex([node.value, srange(node.location)]))
    end

    # { foo: }
    #   ^^^^
    def visit_implicit_node(node)
      raise "Cannot directly compile implicit nodes"
    end

    # foo { |bar,| }
    #           ^
    def visit_implicit_rest_node(node)
      raise "Cannot directly compile implicit rest nodes"
    end

    # case foo; in bar; end
    # ^^^^^^^^^^^^^^^^^^^^^
    def visit_in_node(node)
      pattern = nil
      guard = nil

      case node.pattern
      when IfNode
        pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
        guard = builder.if_guard(token(node.pattern.if_keyword_loc), visit(node.pattern.predicate))
      when UnlessNode
        pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
        guard = builder.unless_guard(token(node.pattern.keyword_loc), visit(node.pattern.predicate))
      else
        pattern = within_pattern { |compiler| node.pattern.accept(compiler) }
      end

      builder.in_pattern(
        token(node.in_loc),
        pattern,
        guard,
        srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset || node.location.end_offset, [";", "then"]),
        visit(node.statements)
      )
    end

    # foo[bar] += baz
    # ^^^^^^^^^^^^^^^
    def visit_index_operator_write_node(node)
      arguments = node.arguments&.arguments || []
      arguments << node.block if node.block

      builder.op_assign(
        builder.index(
          visit(node.receiver),
          token(node.opening_loc),
          visit_all(arguments),
          token(node.closing_loc)
        ),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # foo[bar] &&= baz
    # ^^^^^^^^^^^^^^^^
    alias visit_index_and_write_node visit_index_operator_write_node

    # foo[bar] ||= baz
    # ^^^^^^^^^^^^^^^^
    alias visit_index_or_write_node visit_index_operator_write_node

    # foo[bar], = 1
    # ^^^^^^^^
    def visit_index_target_node(node)
      builder.index_asgn(
        visit(node.receiver),
        token(node.opening_loc),
        visit_all(node.arguments.arguments),
        token(node.closing_loc),
      )
    end

    # @foo
    # ^^^^
    def visit_instance_variable_read_node(node)
      builder.ivar(token(node.location))
    end

    # @foo = 1
    # ^^^^^^^^
    #
    # @foo, @bar = 1
    # ^^^^  ^^^^
    def visit_instance_variable_write_node(node)
      builder.assign(
        builder.assignable(builder.ivar(token(node.name_loc))),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # @foo += bar
    # ^^^^^^^^^^^
    def visit_instance_variable_operator_write_node(node)
      builder.op_assign(
        builder.assignable(builder.ivar(token(node.name_loc))),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # @foo &&= bar
    # ^^^^^^^^^^^^
    alias visit_instance_variable_and_write_node visit_instance_variable_operator_write_node

    # @foo ||= bar
    # ^^^^^^^^^^^^
    alias visit_instance_variable_or_write_node visit_instance_variable_operator_write_node

    # @foo, = bar
    # ^^^^
    def visit_instance_variable_target_node(node)
      builder.assignable(builder.ivar(token(node.location)))
    end

    # 1
    # ^
    def visit_integer_node(node)
      visit_numeric(node, builder.integer([node.value, srange(node.location)]))
    end

    # /foo #{bar}/
    # ^^^^^^^^^^^^
    def visit_interpolated_regular_expression_node(node)
      builder.regexp_compose(
        token(node.opening_loc),
        visit_all(node.parts),
        [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
        builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
      )
    end

    # if /foo #{bar}/ then end
    #    ^^^^^^^^^^^^
    alias visit_interpolated_match_last_line_node visit_interpolated_regular_expression_node

    # "foo #{bar}"
    # ^^^^^^^^^^^^
    def visit_interpolated_string_node(node)
      if node.opening&.start_with?("<<")
        children, closing = visit_heredoc(node)
        builder.string_compose(token(node.opening_loc), children, closing)
      else
        builder.string_compose(
          token(node.opening_loc),
          visit_all(node.parts),
          token(node.closing_loc)
        )
      end
    end

    # :"foo #{bar}"
    # ^^^^^^^^^^^^^
    def visit_interpolated_symbol_node(node)
      builder.symbol_compose(
        token(node.opening_loc),
        visit_all(node.parts),
        token(node.closing_loc)
      )
    end

    # `foo #{bar}`
    # ^^^^^^^^^^^^
    def visit_interpolated_x_string_node(node)
      if node.opening.start_with?("<<")
        children, closing = visit_heredoc(node)
        builder.xstring_compose(token(node.opening_loc), children, closing)
      else
        builder.xstring_compose(
          token(node.opening_loc),
          visit_all(node.parts),
          token(node.closing_loc)
        )
      end
    end

    # foo(bar: baz)
    #     ^^^^^^^^
    def visit_keyword_hash_node(node)
      builder.associate(nil, visit_all(node.elements), nil)
    end

    # def foo(**bar); end
    #         ^^^^^
    #
    # def foo(**); end
    #         ^^
    def visit_keyword_rest_parameter_node(node)
      builder.kwrestarg(
        token(node.operator_loc),
        node.name ? [node.name, srange(node.name_loc)] : nil
      )
    end

    # -> {}
    def visit_lambda_node(node)
      builder.block(
        builder.call_lambda(token(node.operator_loc)),
        [node.opening, srange(node.opening_loc)],
        if node.parameters
          if node.parameters.is_a?(NumberedParametersNode)
            visit(node.parameters)
          else
            builder.args(
              token(node.parameters.opening_loc),
              visit(node.parameters),
              token(node.parameters.closing_loc),
              false
            )
          end
        else
          builder.args(nil, [], nil, false)
        end,
        node.body&.accept(copy_compiler(locals: node.locals)),
        [node.closing, srange(node.closing_loc)]
      )
    end

    # foo
    # ^^^
    def visit_local_variable_read_node(node)
      builder.ident([node.name, srange(node.location)]).updated(:lvar)
    end

    # foo = 1
    # ^^^^^^^
    #
    # foo, bar = 1
    # ^^^  ^^^
    def visit_local_variable_write_node(node)
      builder.assign(
        builder.assignable(builder.ident(token(node.name_loc))),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # foo += bar
    # ^^^^^^^^^^
    def visit_local_variable_operator_write_node(node)
      builder.op_assign(
        builder.assignable(builder.ident(token(node.name_loc))),
        [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
        visit(node.value)
      )
    end

    # foo &&= bar
    # ^^^^^^^^^^^
    alias visit_local_variable_and_write_node visit_local_variable_operator_write_node

    # foo ||= bar
    # ^^^^^^^^^^^
    alias visit_local_variable_or_write_node visit_local_variable_operator_write_node

    # foo, = bar
    # ^^^
    def visit_local_variable_target_node(node)
      if in_pattern
        builder.assignable(builder.match_var([node.name, srange(node.location)]))
      else
        builder.assignable(builder.ident(token(node.location)))
      end
    end

    # foo in bar
    # ^^^^^^^^^^
    def visit_match_predicate_node(node)
      builder.match_pattern_p(
        visit(node.value),
        token(node.operator_loc),
        within_pattern { |compiler| node.pattern.accept(compiler) }
      )
    end

    # foo => bar
    # ^^^^^^^^^^
    def visit_match_required_node(node)
      builder.match_pattern(
        visit(node.value),
        token(node.operator_loc),
        within_pattern { |compiler| node.pattern.accept(compiler) }
      )
    end

    # /(?<foo>foo)/ =~ bar
    # ^^^^^^^^^^^^^^^^^^^^
    def visit_match_write_node(node)
      builder.match_op(
        visit(node.call.receiver),
        token(node.call.message_loc),
        visit(node.call.arguments.arguments.first)
      )
    end

    # A node that is missing from the syntax tree. This is only used in the
    # case of a syntax error. The parser gem doesn't have such a concept, so
    # we invent our own here.
    def visit_missing_node(node)
      raise "Cannot compile missing nodes"
    end

    # module Foo; end
    # ^^^^^^^^^^^^^^^
    def visit_module_node(node)
      builder.def_module(
        token(node.module_keyword_loc),
        visit(node.constant_path),
        node.body&.accept(copy_compiler(locals: node.locals)),
        token(node.end_keyword_loc)
      )
    end

    # foo, bar = baz
    # ^^^^^^^^
    def visit_multi_target_node(node)
      node = node.copy(rest: nil) if node.rest.is_a?(ImplicitRestNode)

      builder.multi_lhs(
        token(node.lparen_loc),
        visit_all([*node.lefts, *node.rest, *node.rights]),
        token(node.rparen_loc)
      )
    end

    # foo, bar = baz
    # ^^^^^^^^^^^^^^
    def visit_multi_write_node(node)
      builder.multi_assign(
        builder.multi_lhs(
          token(node.lparen_loc),
          visit_all([*node.lefts, *node.rest, *node.rights]),
          token(node.rparen_loc)
        ),
        token(node.operator_loc),
        visit(node.value)
      )
    end

    # next
    # ^^^^
    #
    # next foo
    # ^^^^^^^^
    def visit_next_node(node)
      builder.keyword_cmd(
        :next,
        token(node.keyword_loc),
        nil,
        visit(node.arguments) || [],
        nil
      )
    end

    # nil
    # ^^^
    def visit_nil_node(node)
      builder.nil(token(node.location))
    end

    # def foo(**nil); end
    #         ^^^^^
    def visit_no_keywords_parameter_node(node)
      builder.kwnilarg(token(node.operator_loc), token(node.keyword_loc))
    end

    # -> { _1 + _2 }
    # ^^^^^^^^^^^^^^
    def visit_numbered_parameters_node(node)
      builder.numargs(node.maximum)
    end

    # $1
    # ^^
    def visit_numbered_reference_read_node(node)
      builder.nth_ref([node.number, srange(node.location)])
    end

    # def foo(bar: baz); end
    #         ^^^^^^^^
    def visit_optional_keyword_parameter_node(node)
      builder.kwoptarg([node.name, srange(node.name_loc)], visit(node.value))
    end

    # def foo(bar = 1); end
    #         ^^^^^^^
    def visit_optional_parameter_node(node)
      builder.optarg(token(node.name_loc), token(node.operator_loc), visit(node.value))
    end

    # a or b
    # ^^^^^^
    def visit_or_node(node)
      builder.logical_op(:or, visit(node.left), token(node.operator_loc), visit(node.right))
    end

    # def foo(bar, *baz); end
    #         ^^^^^^^^^
    def visit_parameters_node(node)
      params = []

      if node.requireds.any?
        node.requireds.each do |required|
          if required.is_a?(RequiredParameterNode)
            params << visit(required)
          else
            compiler = copy_compiler(in_destructure: true)
            params << required.accept(compiler)
          end
        end
      end

      params.concat(visit_all(node.optionals)) if node.optionals.any?
      params << visit(node.rest) if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)

      if node.posts.any?
        node.posts.each do |post|
          if post.is_a?(RequiredParameterNode)
            params << visit(post)
          else
            compiler = copy_compiler(in_destructure: true)
            params << post.accept(compiler)
          end
        end
      end

      params.concat(visit_all(node.keywords)) if node.keywords.any?
      params << visit(node.keyword_rest) if !node.keyword_rest.nil?
      params << visit(node.block) if !node.block.nil?
      params
    end

    # ()
    # ^^
    #
    # (1)
    # ^^^
    def visit_parentheses_node(node)
      builder.begin(
        token(node.opening_loc),
        visit(node.body),
        token(node.closing_loc)
      )
    end

    # foo => ^(bar)
    #        ^^^^^^
    def visit_pinned_expression_node(node)
      builder.pin(token(node.operator_loc), visit(node.expression))
    end

    # foo = 1 and bar => ^foo
    #                    ^^^^
    def visit_pinned_variable_node(node)
      builder.pin(token(node.operator_loc), visit(node.variable))
    end

    # END {}
    def visit_post_execution_node(node)
      builder.postexe(
        token(node.keyword_loc),
        token(node.opening_loc),
        visit(node.statements),
        token(node.closing_loc)
      )
    end

    # BEGIN {}
    def visit_pre_execution_node(node)
      builder.preexe(
        token(node.keyword_loc),
        token(node.opening_loc),
        visit(node.statements),
        token(node.closing_loc)
      )
    end

    # The top-level program node.
    def visit_program_node(node)
      node.statements.accept(copy_compiler(locals: node.locals))
    end

    # 0..5
    # ^^^^
    def visit_range_node(node)
      if node.exclude_end?
        builder.range_exclusive(
          visit(node.left),
          token(node.operator_loc),
          visit(node.right)
        )
      else
        builder.range_inclusive(
          visit(node.left),
          token(node.operator_loc),
          visit(node.right)
        )
      end
    end

    # if foo .. bar; end
    #    ^^^^^^^^^^
    alias visit_flip_flop_node visit_range_node

    # 1r
    # ^^
    def visit_rational_node(node)
      visit_numeric(node, builder.rational([node.value, srange(node.location)]))
    end

    # redo
    # ^^^^
    def visit_redo_node(node)
      builder.keyword_cmd(:redo, token(node.location))
    end

    # /foo/
    # ^^^^^
    def visit_regular_expression_node(node)
      builder.regexp_compose(
        token(node.opening_loc),
        [builder.string_internal(token(node.content_loc))],
        [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
        builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
      )
    end

    # if /foo/ then end
    #    ^^^^^
    alias visit_match_last_line_node visit_regular_expression_node

    # def foo(bar:); end
    #         ^^^^
    def visit_required_keyword_parameter_node(node)
      builder.kwarg([node.name, srange(node.name_loc)])
    end

    # def foo(bar); end
    #         ^^^
    def visit_required_parameter_node(node)
      builder.arg(token(node.location))
    end

    # foo rescue bar
    # ^^^^^^^^^^^^^^
    def visit_rescue_modifier_node(node)
      builder.begin_body(
        visit(node.expression),
        [
          builder.rescue_body(
            token(node.keyword_loc),
            nil,
            nil,
            nil,
            nil,
            visit(node.rescue_expression)
          )
        ]
      )
    end

    # begin; rescue; end
    #        ^^^^^^^
    def visit_rescue_node(node)
      raise "Cannot directly compile rescue nodes"
    end

    # def foo(*bar); end
    #         ^^^^
    #
    # def foo(*); end
    #         ^
    def visit_rest_parameter_node(node)
      builder.restarg(token(node.operator_loc), token(node.name_loc))
    end

    # retry
    # ^^^^^
    def visit_retry_node(node)
      builder.keyword_cmd(:retry, token(node.location))
    end

    # return
    # ^^^^^^
    #
    # return 1
    # ^^^^^^^^
    def visit_return_node(node)
      builder.keyword_cmd(
        :return,
        token(node.keyword_loc),
        nil,
        visit(node.arguments) || [],
        nil
      )
    end

    # self
    # ^^^^
    def visit_self_node(node)
      builder.self(token(node.location))
    end

    # class << self; end
    # ^^^^^^^^^^^^^^^^^^
    def visit_singleton_class_node(node)
      builder.def_sclass(
        token(node.class_keyword_loc),
        token(node.operator_loc),
        visit(node.expression),
        node.body.accept(copy_compiler(locals: node.locals)),
        token(node.end_keyword_loc)
      )
    end

    # __ENCODING__
    # ^^^^^^^^^^^^
    def visit_source_encoding_node(node)
      builder.accessible(builder.__ENCODING__(token(node.location)))
    end

    # __FILE__
    # ^^^^^^^^
    def visit_source_file_node(node)
      builder.accessible(builder.__FILE__(token(node.location)))
    end

    # __LINE__
    # ^^^^^^^^
    def visit_source_line_node(node)
      builder.accessible(builder.__LINE__(token(node.location)))
    end

    # foo(*bar)
    #     ^^^^
    #
    # def foo((bar, *baz)); end
    #               ^^^^
    #
    # def foo(*); bar(*); end
    #                 ^
    def visit_splat_node(node)
      if node.expression.nil? && locals.include?(:*)
        builder.forwarded_restarg(token(node.operator_loc))
      elsif in_destructure
        builder.restarg(token(node.operator_loc), token(node.expression&.location))
      elsif in_pattern
        builder.match_rest(token(node.operator_loc), token(node.expression&.location))
      else
        builder.splat(token(node.operator_loc), visit(node.expression))
      end
    end

    # A list of statements.
    def visit_statements_node(node)
      builder.compstmt(visit_all(node.body))
    end

    # "foo"
    # ^^^^^
    def visit_string_node(node)
      if node.opening&.start_with?("<<")
        children, closing = visit_heredoc(InterpolatedStringNode.new(node.opening_loc, [node.copy(opening_loc: nil, closing_loc: nil, location: node.content_loc)], node.closing_loc, node.location))
        builder.string_compose(token(node.opening_loc), children, closing)
      elsif node.opening == "?"
        builder.character([node.unescaped, srange(node.location)])
      else
        builder.string_compose(
          token(node.opening_loc),
          [builder.string_internal([node.unescaped, srange(node.content_loc)])],
          token(node.closing_loc)
        )
      end
    end

    # super(foo)
    # ^^^^^^^^^^
    def visit_super_node(node)
      arguments = node.arguments&.arguments || []
      block = node.block

      if block.is_a?(BlockArgumentNode)
        arguments = [*arguments, block]
        block = nil
      end

      visit_block(
        builder.keyword_cmd(
          :super,
          token(node.keyword_loc),
          token(node.lparen_loc),
          visit_all(arguments),
          token(node.rparen_loc)
        ),
        block
      )
    end

    # :foo
    # ^^^^
    def visit_symbol_node(node)
      if node.closing_loc.nil?
        if node.opening_loc.nil?
          builder.symbol_internal([node.unescaped, srange(node.location)])
        else
          builder.symbol([node.unescaped, srange(node.location)])
        end
      else
        builder.symbol_compose(
          token(node.opening_loc),
          [builder.string_internal([node.unescaped, srange(node.value_loc)])],
          token(node.closing_loc)
        )
      end
    end

    # true
    # ^^^^
    def visit_true_node(node)
      builder.true(token(node.location))
    end

    # undef foo
    # ^^^^^^^^^
    def visit_undef_node(node)
      builder.undef_method(token(node.keyword_loc), visit_all(node.names))
    end

    # unless foo; bar end
    # ^^^^^^^^^^^^^^^^^^^
    #
    # bar unless foo
    # ^^^^^^^^^^^^^^
    def visit_unless_node(node)
      if node.keyword_loc.start_offset == node.location.start_offset
        builder.condition(
          token(node.keyword_loc),
          visit(node.predicate),
          if node.then_keyword_loc
            token(node.then_keyword_loc)
          else
            srange_find(node.predicate.location.end_offset, (node.statements&.location || node.consequent&.location || node.end_keyword_loc).start_offset, [";"])
          end,
          visit(node.consequent),
          token(node.consequent&.else_keyword_loc),
          visit(node.statements),
          token(node.end_keyword_loc)
        )
      else
        builder.condition_mod(
          visit(node.consequent),
          visit(node.statements),
          token(node.keyword_loc),
          visit(node.predicate)
        )
      end
    end

    # until foo; bar end
    # ^^^^^^^^^^^^^^^^^
    #
    # bar until foo
    # ^^^^^^^^^^^^^
    def visit_until_node(node)
      if node.location.start_offset == node.keyword_loc.start_offset
        builder.loop(
          :until,
          token(node.keyword_loc),
          visit(node.predicate),
          srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
          visit(node.statements),
          token(node.closing_loc)
        )
      else
        builder.loop_mod(
          :until,
          visit(node.statements),
          token(node.keyword_loc),
          visit(node.predicate)
        )
      end
    end

    # case foo; when bar; end
    #           ^^^^^^^^^^^^^
    def visit_when_node(node)
      builder.when(
        token(node.keyword_loc),
        visit_all(node.conditions),
        srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset || (node.conditions.last.location.end_offset + 1), [";", "then"]),
        visit(node.statements)
      )
    end

    # while foo; bar end
    # ^^^^^^^^^^^^^^^^^^
    #
    # bar while foo
    # ^^^^^^^^^^^^^
    def visit_while_node(node)
      if node.location.start_offset == node.keyword_loc.start_offset
        builder.loop(
          :while,
          token(node.keyword_loc),
          visit(node.predicate),
          srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
          visit(node.statements),
          token(node.closing_loc)
        )
      else
        builder.loop_mod(
          :while,
          visit(node.statements),
          token(node.keyword_loc),
          visit(node.predicate)
        )
      end
    end

    # `foo`
    # ^^^^^
    def visit_x_string_node(node)
      if node.opening&.start_with?("<<")
        children, closing = visit_heredoc(InterpolatedXStringNode.new(node.opening_loc, [StringNode.new(0, nil, node.content_loc, nil, node.unescaped, node.content_loc)], node.closing_loc, node.location))
        builder.xstring_compose(token(node.opening_loc), children, closing)
      else
        builder.xstring_compose(
          token(node.opening_loc),
          [builder.string_internal([node.unescaped, srange(node.content_loc)])],
          token(node.closing_loc)
        )
      end
    end

    # yield
    # ^^^^^
    #
    # yield 1
    # ^^^^^^^
    def visit_yield_node(node)
      builder.keyword_cmd(
        :yield,
        token(node.keyword_loc),
        token(node.lparen_loc),
        visit(node.arguments) || [],
        token(node.rparen_loc)
      )
    end

    private

    def copy_compiler(locals: self.locals, in_destructure: self.in_destructure, in_pattern: self.in_pattern)
      ParserCompiler.new(parser, offset_cache, locals: locals, in_destructure: in_destructure, in_pattern: in_pattern)
    end

    # Blocks can have a special set of parameters that automatically expand
    # when given arrays if they have a single required parameter and no other
    # parameters.
    def procarg0?(parameters)
      parameters &&
        parameters.requireds.length == 1 &&
        parameters.optionals.empty? &&
        parameters.rest.nil? &&
        parameters.posts.empty? &&
        parameters.keywords.empty? &&
        parameters.keyword_rest.nil? &&
        parameters.block.nil?
    end

    # Locations in the parser gem AST are generated using this class. We store a
    # reference to its constant to make it slightly faster to look up.
    Range = ::Parser::Source::Range

    # Constructs a new source range from the given start and end offsets.
    def srange(location)
      Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset]) if location
    end

    # Constructs a new source range from the given start and end offsets.
    def srange_offsets(start_offset, end_offset)
      Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
    end

    # Constructs a new source range by finding the given tokens between the
    # given start offset and end offset. If the needle is not found, it
    # returns nil.
    def srange_find(start_offset, end_offset, tokens)
      tokens.find do |token|
        next unless (index = source_buffer.source.byteslice(start_offset...end_offset).index(token))
        offset = start_offset + index
        return [token, Range.new(source_buffer, offset_cache[offset], offset_cache[offset + token.length])]
      end
    end

    # Transform a location into a token that the parser gem expects.
    def token(location)
      [location.slice, Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset])] if location
    end

    # Visit a block node on a call.
    def visit_block(call, block)
      if block
        builder.block(
          call,
          token(block.opening_loc),
          if (parameters = block.parameters)
            if parameters.is_a?(NumberedParametersNode)
              visit(parameters)
            else
              builder.args(
                token(parameters.opening_loc),
                if procarg0?(parameters.parameters)
                  parameter = parameters.parameters.requireds.first
                  [builder.procarg0(visit(parameter))].concat(visit_all(parameters.locals))
                else
                  visit(parameters)
                end,
                token(parameters.closing_loc),
                false
              )
            end
          else
            builder.args(nil, [], nil, false)
          end,
          visit(block.body),
          token(block.closing_loc)
        )
      else
        call
      end
    end

    # Visit a heredoc that can be either a string or an xstring.
    def visit_heredoc(node)
      children = []
      node.parts.each do |part|
        pushing =
          if part.is_a?(StringNode) && part.unescaped.count("\n") > 1
            unescaped = part.unescaped.split("\n")
            escaped = part.content.split("\n")

            escaped_lengths =
              if node.opening.end_with?("'")
                escaped.map { |line| line.bytesize + 1 }
              else
                escaped.chunk_while { |before, after| before.match?(/(?<!\\)\\$/) }.map { |line| line.join.bytesize + line.length }
              end

            start_offset = part.location.start_offset
            end_offset = nil

            unescaped.zip(escaped_lengths).map do |unescaped_line, escaped_length|
              end_offset = start_offset + (escaped_length || 0)
              inner_part = builder.string_internal(["#{unescaped_line}\n", srange_offsets(start_offset, end_offset)])

              start_offset = end_offset
              inner_part
            end
          else
            [visit(part)]
          end

        pushing.each do |child|
          if child.type == :str && child.children.last == ""
            # nothing
          elsif child.type == :str && children.last && children.last.type == :str && !children.last.children.first.end_with?("\n")
            children.last.children.first << child.children.first
          else
            children << child
          end
        end
      end

      closing = node.closing
      closing_t = [closing.chomp, srange_offsets(node.closing_loc.start_offset, node.closing_loc.end_offset - closing[/\s+$/].length)]

      [children, closing_t]
    end

    # Visit a numeric node and account for the optional sign.
    def visit_numeric(node, value)
      if (slice = node.slice).match?(/^[+-]/)
        builder.unary_num(
          [slice[0].to_sym, srange_offsets(node.location.start_offset, node.location.start_offset + 1)],
          value
        )
      else
        value
      end
    end

    # Within the given block, track that we're within a pattern.
    def within_pattern
      begin
        parser.pattern_variables.push
        yield copy_compiler(in_pattern: true)
      ensure
        parser.pattern_variables.pop
      end
    end
  end
end

# Store an alias to the compiler on the Parser::Prism namespace to be more
# consistent with expected constants. We put it on the Prism namespace in the
# first place to make the constant lookups faster.
Parser::Prism::Compiler = Prism::ParserCompiler