Class: Prism::Translation::Ripper

# File 'lib/prism/translation/ripper.rb', line 59

def self.lex(src, filename = "-", lineno = 1, raise_errors: false)
  coerced = coerce_source(src)
  result = Prism.lex_compat(coerced, filepath: filename, line: lineno, version: "current", encoding: coerced.encoding)

  if result.failure? && raise_errors
    raise SyntaxError, result.errors.first.message
  else
    result.value
  end
end

# File 'lib/prism/translation/ripper.rb', line 525

def self.lex_state_name(state)
  LEX_STATE_NAMES.filter_map { |flag, name| name if state & flag != 0  }.join("|")
end

# File 'lib/prism/translation/ripper.rb', line 33

def self.parse(src, filename = "(ripper)", lineno = 1)
  new(src, filename, lineno).parse
end

# File 'lib/prism/translation/ripper.rb', line 397

def self.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

# File 'lib/prism/translation/ripper.rb', line 432

def self.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

# File 'lib/prism/translation/ripper.rb', line 79

def self.tokenize(...)
  lex(...).map { |token| token[2] }
end

# File 'lib/prism/translation/ripper.rb', line 558

def error?
  result.failure?
end

# File 'lib/prism/translation/ripper.rb', line 535

attr_reader :filename

# File 'lib/prism/translation/ripper.rb', line 538

attr_reader :lineno

# File 'lib/prism/translation/ripper.rb', line 532

attr_reader :source

# File 'lib/prism/translation/ripper.rb', line 4204

def _dispatch_1(arg); arg end

# File 'lib/prism/translation/ripper.rb', line 4205

def _dispatch_2(arg, _); arg end

# File 'lib/prism/translation/ripper.rb', line 4206

def _dispatch_3(arg, _, _); arg end

# File 'lib/prism/translation/ripper.rb', line 4207

def _dispatch_4(arg, _, _, _); arg end

# File 'lib/prism/translation/ripper.rb', line 4208

def _dispatch_5(arg, _, _, _, _); arg end

# File 'lib/prism/translation/ripper.rb', line 4209

def _dispatch_7(arg, _, _, _, _, _, _); arg end

# File 'lib/prism/translation/ripper.rb', line 4192

def bounds(location)
  @lineno, @column = line_and_column_cache.line_and_column(location.start_offset)
end

# File 'lib/prism/translation/ripper.rb', line 1464

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

# File 'lib/prism/translation/ripper.rb', line 4231

def compile_error(msg)
end

# File 'lib/prism/translation/ripper.rb', line 4246

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

  string.replace(string[cursor..])
  cursor
end

# File 'lib/prism/translation/ripper.rb', line 1429

private def get_arguments_and_block(arguments_node, block_node)
  arguments = arguments_node&.arguments || []
  block = block_node

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

  [arguments, block]
end

# File 'lib/prism/translation/ripper.rb', line 4084

def line_and_column_cache
  @line_and_column_cache ||= LineAndColumnCache.new(result.source)
end

# File 'lib/prism/translation/ripper.rb', line 563

def parse
  result.comments.each do |comment|
    location = comment.location
    bounds(location)

    if comment.is_a?(InlineComment)
      # Inline comments always contain a newline if the line itself contains it
      if result.source.source.bytesize > comment.location.end_offset
        on_comment("#{comment.slice}\n")
      else
        on_comment(comment.slice)
      end
    else
      offset = location.start_offset
      lines = comment.slice.lines

      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|
      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
  else
    result.value.accept(self)
  end
end

# File 'lib/prism/translation/ripper.rb', line 4080

def result
  @result ||= Prism.parse(source, partial_script: true, version: "current", freeze: true, encoding: source.encoding)
end

# File 'lib/prism/translation/ripper.rb', line 4093

def trailing_comma?(left, right)
  source.byteslice(left.end_offset...right.start_offset).include?(",")
end

# File 'lib/prism/translation/ripper.rb', line 672

def visit_alias_global_variable_node(node)
  bounds(node.keyword_loc)
  on_kw("alias")

  new_name = visit_alias_global_variable_node_value(node.new_name)
  old_name = visit_alias_global_variable_node_value(node.old_name)

  bounds(node.location)
  on_var_alias(new_name, old_name)
end

# File 'lib/prism/translation/ripper.rb', line 684

private def visit_alias_global_variable_node_value(node)
  bounds(node.location)

  case node
  when BackReferenceReadNode
    on_backref(node.slice)
  when GlobalVariableReadNode
    on_gvar(node.name.to_s)
  else
    raise
  end
end

# File 'lib/prism/translation/ripper.rb', line 659

def visit_alias_method_node(node)
  bounds(node.keyword_loc)
  on_kw("alias")

  new_name = visit(node.new_name)
  old_name = visit(node.old_name)

  bounds(node.location)
  on_alias(new_name, old_name)
end

# File 'lib/prism/translation/ripper.rb', line 699

def visit_alternation_pattern_node(node)
  left = visit_pattern_node(node.left)

  bounds(node.operator_loc)
  on_op("|")

  right = visit_pattern_node(node.right)

  bounds(node.location)
  on_binary(left, :|, right)
end

# File 'lib/prism/translation/ripper.rb', line 729

def visit_and_node(node)
  left = visit(node.left)

  bounds(node.operator_loc)
  if node.operator == "and"
    on_kw("and")
  else
    on_op("&&")
  end

  right = visit(node.right)

  bounds(node.location)
  on_binary(left, node.operator.to_sym, right)
end

# File 'lib/prism/translation/ripper.rb', line 902

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

# File 'lib/prism/translation/ripper.rb', line 955

def visit_arguments_node(node)
  arguments, _ = visit_call_node_arguments(node, nil, false)
  arguments
end

# File 'lib/prism/translation/ripper.rb', line 747

def visit_array_node(node)
  case (opening = node.opening)
  when /^%w/
    opening_loc = node.opening_loc
    bounds(opening_loc)
    on_qwords_beg(opening)

    elements = on_qwords_new
    previous = nil

    node.elements.each do |element|
      visit_words_sep(opening_loc, previous, element)

      bounds(element.location)
      elements = on_qwords_add(elements, on_tstring_content(element.content))

      previous = element
    end

    visit_words_sep(opening_loc, node.elements.last, node.closing_loc)

    bounds(node.closing_loc)
    on_tstring_end(node.closing)
  when /^%i/
    opening_loc = node.opening_loc
    bounds(opening_loc)
    on_qsymbols_beg(opening)

    elements = on_qsymbols_new
    previous = nil

    node.elements.each do |element|
      visit_words_sep(opening_loc, previous, element)

      bounds(element.location)
      elements = on_qsymbols_add(elements, on_tstring_content(element.value))

      previous = element
    end

    visit_words_sep(opening_loc, node.elements.last, node.closing_loc)

    bounds(node.closing_loc)
    on_tstring_end(node.closing)
  when /^%W/
    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_words_sep(opening_loc, node.elements.last, node.closing_loc)

    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

    visit_words_sep(opening_loc, node.elements.last, node.closing_loc)

    bounds(node.closing_loc)
    on_tstring_end(node.closing)
  else
    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

  bounds(node.location)
  on_array(elements)
end

# File 'lib/prism/translation/ripper.rb', line 921

def visit_array_pattern_node(node)
  constant = visit(node.constant)

  if node.opening_loc
    bounds(node.opening_loc)
    node.opening == "[" ? on_lbracket("[") : on_lparen("(")
  end

  requireds = visit_all(node.requireds) if node.requireds.any?
  rest =
    if (rest_node = node.rest).is_a?(SplatNode)
      bounds(rest_node.operator_loc)
      on_op("*")

      if rest_node.expression.nil?
        bounds(rest_node.location)
        on_var_field(nil)
      else
        visit(rest_node.expression)
      end
    end

  posts = visit_all(node.posts) if node.posts.any?

  if node.closing_loc
    bounds(node.closing_loc)
    node.closing == "]" ? on_rbracket("]") : on_rparen(")")
  end
  bounds(node.location)
  on_aryptn(constant, requireds, rest, posts)
end

# File 'lib/prism/translation/ripper.rb', line 962

def visit_assoc_node(node)
  key = visit(node.key)

  if node.operator_loc
    bounds(node.operator_loc)
    on_op("=>")
  end

  value = visit(node.value)

  bounds(node.location)
  on_assoc_new(key, value)
end

# File 'lib/prism/translation/ripper.rb', line 981

def visit_assoc_splat_node(node)
  bounds(node.operator_loc)
  on_op("**")

  value = visit(node.value)

  bounds(node.location)
  on_assoc_splat(value)
end

# File 'lib/prism/translation/ripper.rb', line 993

def visit_back_reference_read_node(node)
  bounds(node.location)
  on_backref(node.slice)
end

# File 'lib/prism/translation/ripper.rb', line 1000

def visit_begin_node(node)
  if node.begin_keyword_loc
    bounds(node.begin_keyword_loc)
    on_kw("begin")
  end

  clauses = visit_begin_node_clauses(node.begin_keyword_loc, node, false)

  if node.end_keyword_loc
    bounds(node.end_keyword_loc)
    on_kw("end")
  end

  bounds(node.location)
  on_begin(clauses)
end

# File 'lib/prism/translation/ripper.rb', line 1018

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
      body = node.statements.body
      body = [nil, *body] 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?
      bounds(else_clause_node.else_keyword_loc)
      on_kw("else")

      else_statements =
        if else_clause_node.statements.nil?
          [nil]
        else
          body = else_clause_node.statements.body
          body = [nil, *body] 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_bodystmt(statements, rescue_clause, else_clause, ensure_clause)
end

# File 'lib/prism/translation/ripper.rb', line 1077

def visit_block_argument_node(node)
  bounds(node.operator_loc)
  on_op("&")
  visit(node.expression)
end

# File 'lib/prism/translation/ripper.rb', line 1085

def visit_block_local_variable_node(node)
  bounds(node.location)
  on_ident(node.name.to_s)
end

# File 'lib/prism/translation/ripper.rb', line 1091

def visit_block_node(node)
  braces = node.opening == "{"
  bounds(node.opening_loc)
  if braces
    on_lbrace("{")
  else
    on_kw("do")
  end

  parameters = visit(node.parameters)

  body =
    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 = [nil, *stmts] if void_stmt?(node.parameters&.location || node.opening_loc, node.body.location, false)
      stmts = visit_statements_node_body(stmts)

      bounds(node.body.location)
      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.closing_loc)
    on_rbrace("}")
  else
    bounds(node.closing_loc)
    on_kw("end")
  end

  if braces
    bounds(node.location)
    on_brace_block(parameters, body)
  else
    bounds(node.location)
    on_do_block(parameters, body)
  end
end

# File 'lib/prism/translation/ripper.rb', line 1142

def visit_block_parameter_node(node)
  bounds(node.operator_loc)
  on_op("&")

  if node.name_loc.nil?
    bounds(node.location)
    on_blockarg(nil)
  else
    bounds(node.name_loc)
    name = on_ident(node.name.to_s)

    bounds(node.location)
    on_blockarg(name)
  end
end

# File 'lib/prism/translation/ripper.rb', line 1159

def visit_block_parameters_node(node)
  bounds(node.opening_loc)
  on_op("|")

  parameters =
    if node.parameters.nil?
      on_params(nil, nil, nil, nil, nil, nil, nil)
    else
      visit(node.parameters)
    end

  locals =
    if node.locals.any?
      visit_all(node.locals)
    else
      false
    end

  bounds(node.closing_loc)
  on_op("|")

  bounds(node.location)
  on_block_var(parameters, locals)
end

# File 'lib/prism/translation/ripper.rb', line 1056

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 = [nil, *body] 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

# File 'lib/prism/translation/ripper.rb', line 1189

def visit_break_node(node)
  bounds(node.keyword_loc)
  on_kw("break")

  if node.arguments.nil?
    bounds(node.location)
    on_break(on_args_new)
  else
    arguments = visit(node.arguments)

    bounds(node.location)
    on_break(arguments)
  end
end

# File 'lib/prism/translation/ripper.rb', line 1495

def visit_call_and_write_node(node)
  receiver = visit(node.receiver)

  bounds(node.call_operator_loc)
  call_operator = visit_call_operator(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

# File 'lib/prism/translation/ripper.rb', line 1212

def visit_call_node(node)
  if node.call_operator_loc.nil?
    case node.name
    when :[]
      receiver = visit(node.receiver)

      bounds(node.opening_loc)
      on_lbracket("[")

      arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc))

      bounds(node.closing_loc)
      on_rbracket("]")

      block = visit(block_node)

      bounds(node.location)
      call = on_aref(receiver, arguments)

      if block_node
        bounds(node.location)
        on_method_add_block(call, block)
      else
        call
      end
    when :[]=
      receiver = visit(node.receiver)

      bounds(node.opening_loc)
      on_lbracket("[")

      *arguments, last_argument = node.arguments.arguments
      arguments << node.block if !node.block.nil?

      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.closing_loc)
      on_rbracket("]")
      bounds(node.equal_loc)
      on_op("=")

      bounds(node.location)
      call = on_aref_field(receiver, arguments)
      value = visit_write_value(last_argument)

      bounds(last_argument.location)
      on_assign(call, value)
    when :-@, :+@, :~
      bounds(node.message_loc)
      on_op(node.message)

      receiver = visit(node.receiver)
      bounds(node.location)
      on_unary(node.name, receiver)
    when :!
      bounds(node.message_loc)
      if node.message == "not"
        on_kw("not")

        if node.opening_loc
          bounds(node.opening_loc)
          on_lparen("(")
        end

        receiver =
          if node.receiver.is_a?(ParenthesesNode) && node.receiver.body.nil?
            # The parens in `not()` just emit parens and nothing else.
            bounds(node.receiver.opening_loc)
            on_lparen("(")
            bounds(node.receiver.closing_loc)
            on_rparen(")")
            nil
          else
            visit(node.receiver)
          end

        if node.closing_loc
          bounds(node.closing_loc)
          on_rparen(")")
        end
        bounds(node.location)
        on_unary(:not, receiver)
      else
        on_op("!")

        receiver = visit(node.receiver)

        bounds(node.location)
        on_unary(:!, receiver)
      end
    when BINARY_OPERATORS
      receiver = visit(node.receiver)

      bounds(node.message_loc)
      on_op(node.message)

      value = visit(node.arguments.arguments.first)

      bounds(node.location)
      on_binary(receiver, node.name, value)
    else
      bounds(node.message_loc)
      message = visit_token(node.message, false)

      if node.variable_call?
        on_vcall(message)
      else
        if node.opening_loc
          bounds(node.opening_loc)
          on_lparen("(")
        end

        arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))

        if node.closing_loc
          bounds(node.closing_loc)
          on_rparen(")")
        end

        block = visit(block_node)
        call =
          if node.opening_loc.nil? && get_arguments_and_block(node.arguments, node.block).first.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_node
          bounds(node.block.location)
          on_method_add_block(call, block)
        else
          call
        end
      end
    end
  else
    receiver = visit(node.receiver)

    bounds(node.call_operator_loc)
    call_operator = visit_call_operator(node.call_operator)

    message =
      if node.message_loc.nil?
        :call
      else
        bounds(node.message_loc)
        visit_token(node.message, false)
      end

    if node.equal_loc
      bounds(node.equal_loc)
      on_op("=")
    end

    if node.name.end_with?("=") && !node.message.end_with?("=") && !node.arguments.nil? && node.block.nil?
      value = visit_write_value(node.arguments.arguments.first)

      bounds(node.location)
      on_assign(on_field(receiver, call_operator, message), value)
    else
      if node.opening_loc
        bounds(node.opening_loc)
        on_lparen("(")
      end

      arguments, block_node = visit_call_node_arguments(node.arguments, node.block, trailing_comma?(node.arguments&.location || node.location, node.closing_loc || node.location))

      if node.closing_loc
        bounds(node.closing_loc)
        on_rparen(")")
      end

      block = visit(block_node)
      call =
        if node.opening_loc.nil?
          bounds(node.location)

          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_node
        bounds(node.block.location)
        on_method_add_block(call, block)
      else
        call
      end
    end
  end
end

# File 'lib/prism/translation/ripper.rb', line 1443

private def visit_call_node_arguments(arguments_node, block_node, trailing_comma)
  arguments, block = get_arguments_and_block(arguments_node, block_node)

  [
    if arguments.length == 1 && arguments.first.is_a?(ForwardingArgumentsNode)
      visit(arguments.first)
    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,
    block,
  ]
end

# File 'lib/prism/translation/ripper.rb', line 4130

def visit_call_operator(token)
  token == "." ? on_period(token) : on_op(token)
end

# File 'lib/prism/translation/ripper.rb', line 1473

def visit_call_operator_write_node(node)
  receiver = visit(node.receiver)

  bounds(node.call_operator_loc)
  call_operator = visit_call_operator(node.call_operator)

  bounds(node.message_loc)
  message = visit_token(node.message)

  bounds(node.location)
  target = on_field(receiver, call_operator, message)

  bounds(node.binary_operator_loc)
  operator = on_op("#{node.binary_operator}=")
  value = visit_write_value(node.value)

  bounds(node.location)
  on_opassign(target, operator, value)
end

# File 'lib/prism/translation/ripper.rb', line 1517

def visit_call_or_write_node(node)
  receiver = visit(node.receiver)

  bounds(node.call_operator_loc)
  call_operator = visit_call_operator(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

# File 'lib/prism/translation/ripper.rb', line 1539

def visit_call_target_node(node)
  if node.call_operator == "::"
    receiver = visit(node.receiver)

    bounds(node.call_operator_loc)
    on_op("::")

    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_call_operator(node.call_operator)

    bounds(node.message_loc)
    message = visit_token(node.message)

    bounds(node.location)
    on_field(receiver, call_operator, message)
  end
end

# File 'lib/prism/translation/ripper.rb', line 1567

def visit_capture_pattern_node(node)
  value = visit(node.value)

  bounds(node.operator_loc)
  on_op("=>")

  target = visit(node.target)

  bounds(node.location)
  on_binary(value, :"=>", target)
end

# File 'lib/prism/translation/ripper.rb', line 1605

def visit_case_match_node(node)
  bounds(node.case_keyword_loc)
  on_kw("case")

  predicate = visit(node.predicate)
  visited_conditions = node.conditions.map do | condition|
    visit(condition)
  end
  visited_else_clause = visit(node.else_clause)

  if !node.else_clause
    bounds(node.end_keyword_loc)
    on_kw("end")
  end

  clauses =
    visited_conditions.reverse_each.inject(visited_else_clause) do |current, condition|
      on_in(*condition, current)
    end

  bounds(node.location)
  on_case(predicate, clauses)
end

# File 'lib/prism/translation/ripper.rb', line 1581

def visit_case_node(node)
  bounds(node.case_keyword_loc)
  on_kw("case")

  predicate = visit(node.predicate)
  visited_conditions = node.conditions.map { |condition| visit(condition) }
  visited_else_clause = visit(node.else_clause)

  if !node.else_clause
    bounds(node.end_keyword_loc)
    on_kw("end")
  end

  clauses =
    visited_conditions.reverse_each.inject(visited_else_clause) do |current, condition|
      on_when(*condition, current)
    end

  bounds(node.location)
  on_case(predicate, clauses)
end

# File 'lib/prism/translation/ripper.rb', line 1631

def visit_class_node(node)
  bounds(node.class_keyword_loc)
  on_kw("class")

  constant_path =
    if node.constant_path.is_a?(ConstantReadNode)
      bounds(node.constant_path.location)
      on_const_ref(on_const(node.constant_path.name.to_s))
    else
      visit(node.constant_path)
    end

  if node.inheritance_operator_loc
    bounds(node.inheritance_operator_loc)
    on_op("<")
  end

  superclass = visit(node.superclass)
  bodystmt = visit_body_node(node.superclass&.location || node.constant_path.location, node.body, node.superclass.nil?)

  bounds(node.end_keyword_loc)
  on_kw("end")

  bounds(node.location)
  on_class(constant_path, superclass, bodystmt)
end

# File 'lib/prism/translation/ripper.rb', line 1696

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

# File 'lib/prism/translation/ripper.rb', line 1682

def visit_class_variable_operator_write_node(node)
  bounds(node.name_loc)
  target = on_var_field(on_cvar(node.name.to_s))

  bounds(node.binary_operator_loc)
  operator = on_op("#{node.binary_operator}=")
  value = visit_write_value(node.value)

  bounds(node.location)
  on_opassign(target, operator, value)
end

# File 'lib/prism/translation/ripper.rb', line 1710

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

# File 'lib/prism/translation/ripper.rb', line 1660

def visit_class_variable_read_node(node)
  bounds(node.location)
  on_var_ref(on_cvar(node.slice))
end

# File 'lib/prism/translation/ripper.rb', line 1724

def visit_class_variable_target_node(node)
  bounds(node.location)
  on_var_field(on_cvar(node.name.to_s))
end

# File 'lib/prism/translation/ripper.rb', line 1667

def visit_class_variable_write_node(node)
  bounds(node.name_loc)
  target = on_var_field(on_cvar(node.name.to_s))

  bounds(node.operator_loc)
  on_op("=")

  value = visit_write_value(node.value)

  bounds(node.location)
  on_assign(target, value)
end

# File 'lib/prism/translation/ripper.rb', line 1767

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

# File 'lib/prism/translation/ripper.rb', line 1753

def visit_constant_operator_write_node(node)
  bounds(node.name_loc)
  target = on_var_field(on_const(node.name.to_s))

  bounds(node.binary_operator_loc)
  operator = on_op("#{node.binary_operator}=")
  value = visit_write_value(node.value)

  bounds(node.location)
  on_opassign(target, operator, value)
end