Prism::Translation::RubyParser::Compiler

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 31
def initialize(file, in_def: false, in_pattern: false)
  @file = file
  @in_def = in_def
  @in_pattern = in_pattern
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 403
        def class_variable_write_type
  in_def ? :cvasgn : :cvdecl
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1476
def copy_compiler(in_def: self.in_def, in_pattern: self.in_pattern)
  Compiler.new(file, in_def: in_def, in_pattern: in_pattern)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 308
        def op_asgn?(node)
  node.call_operator == "::" || (node.value.is_a?(CallNode) && node.value.opening_loc.nil? && !node.value.arguments.nil?)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 314
        def op_asgn_type(node, type)
  node.safe_navigation? ? :"safe_#{type}" : type
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1481
def s(node, *arguments)
  result = Sexp.new(*arguments)
  result.file = file
  result.line = node.location.start_line
  result.line_max = node.location.end_line
  result
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 45
def visit_alias_global_variable_node(node)
  s(node, :valias, node.new_name.name, node.old_name.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 39
def visit_alias_method_node(node)
  s(node, :alias, visit(node.new_name), visit(node.old_name))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 51
def visit_alternation_pattern_node(node)
  s(node, :or, visit(node.left), visit(node.right))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 57
def visit_and_node(node)
  s(node, :and, visit(node.left), visit(node.right))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 96
def visit_arguments_node(node)
  raise "Cannot visit arguments directly"
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 63
def visit_array_node(node)
  if in_pattern
    s(node, :array_pat, nil).concat(visit_all(node.elements))
  else
    s(node, :array).concat(visit_all(node.elements))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 73
def visit_array_pattern_node(node)
  if node.constant.nil? && node.requireds.empty? && node.rest.nil? && node.posts.empty?
    s(node, :array_pat)
  else
    result = s(node, :array_pat, visit_pattern_constant(node.constant)).concat(visit_all(node.requireds))

    case node.rest
    when SplatNode
      result << :"*#{node.rest.expression&.name}"
    when ImplicitRestNode
      result << :*

      # This doesn't make any sense at all, but since we're trying to
      # replicate the behavior directly, we'll copy it.
      result.line(666)
    end

    result.concat(visit_all(node.posts))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 102
def visit_assoc_node(node)
  [visit(node.key), visit(node.value)]
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 111
def visit_assoc_splat_node(node)
  if node.value.nil?
    [s(node, :kwsplat)]
  else
    [s(node, :kwsplat, visit(node.value))]
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 121
def visit_back_reference_read_node(node)
  s(node, :back_ref, node.name.name.delete_prefix("$").to_sym)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 127
def visit_begin_node(node)
  result = node.statements.nil? ? s(node, :nil) : visit(node.statements)

  if !node.rescue_clause.nil?
    if !node.statements.nil?
      result = s(node.statements, :rescue, result, visit(node.rescue_clause))
    else
      result = s(node.rescue_clause, :rescue, visit(node.rescue_clause))
    end

    current = node.rescue_clause
    until (current = current.consequent).nil?
      result << visit(current)
    end
  end

  if !node.else_clause&.statements.nil?
    result << visit(node.else_clause)
  end

  if !node.ensure_clause.nil?
    if !node.statements.nil? || !node.rescue_clause.nil? || !node.else_clause.nil?
      result = s(node.statements || node.rescue_clause || node.else_clause || node.ensure_clause, :ensure, result, visit(node.ensure_clause))
    else
      result = s(node.ensure_clause, :ensure, visit(node.ensure_clause))
    end
  end

  result
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1491
def visit_block(node, sexp, block)
  if block.nil?
    sexp
  else
    parameters =
      case block.parameters
      when nil, NumberedParametersNode
        0
      else
        visit(block.parameters)
      end

    if block.body.nil?
      s(node, :iter, sexp, parameters)
    else
      s(node, :iter, sexp, parameters, visit(block.body))
    end
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 160
def visit_block_argument_node(node)
  s(node, :block_pass).tap do |result|
    result << visit(node.expression) unless node.expression.nil?
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 168
def visit_block_local_variable_node(node)
  node.name
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 173
def visit_block_node(node)
  s(node, :block_pass, visit(node.expression))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 179
def visit_block_parameter_node(node)
  :"&#{node.name}"
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 184
def visit_block_parameters_node(node)
  # If this block parameters has no parameters and is using pipes, then
  # it inherits its location from its shadow locals, even if they're not
  # on the same lines as the pipes.
  shadow_loc = true

  result =
    if node.parameters.nil?
      s(node, :args)
    else
      shadow_loc = false
      visit(node.parameters)
    end

  if node.opening == "("
    result.line = node.opening_loc.start_line
    result.line_max = node.closing_loc.end_line
    shadow_loc = false
  end

  if node.locals.any?
    shadow = s(node, :shadow).concat(visit_all(node.locals))
    shadow.line = node.locals.first.location.start_line
    shadow.line_max = node.locals.last.location.end_line
    result << shadow

    if shadow_loc
      result.line = shadow.line
      result.line_max = shadow.line_max
    end
  end

  result
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 224
def visit_break_node(node)
  if node.arguments.nil?
    s(node, :break)
  elsif node.arguments.arguments.length == 1
    s(node, :break, visit(node.arguments.arguments.first))
  else
    s(node, :break, s(node.arguments, :array).concat(visit_all(node.arguments.arguments)))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 287
def visit_call_and_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"&&")
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"&&", visit_write_value(node.value))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 242
def visit_call_node(node)
  case node.name
  when :!~
    return s(node, :not, visit(node.copy(name: :"=~")))
  when :=~
    if node.arguments&.arguments&.length == 1 && node.block.nil?
      case node.receiver
      when StringNode
        return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
      when RegularExpressionNode, InterpolatedRegularExpressionNode
        return s(node, :match2, visit(node.receiver), visit(node.arguments.arguments.first))
      end
    end
  end

  type = node.attribute_write? ? :attrasgn : :call
  type = :"safe_#{type}" if node.safe_navigation?

  arguments = node.arguments&.arguments || []
  write_value = arguments.pop if type == :attrasgn
  block = node.block

  if block.is_a?(BlockArgumentNode)
    arguments << block
    block = nil
  end

  result = s(node, type, visit(node.receiver), node.name).concat(visit_all(arguments))
  result << visit_write_value(write_value) unless write_value.nil?

  visit_block(node, result, block)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 277
def visit_call_operator_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.binary_operator)
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.binary_operator, visit_write_value(node.value))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 297
def visit_call_or_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"||")
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"||", visit_write_value(node.value))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 320
def visit_call_target_node(node)
  s(node, :attrasgn, visit(node.receiver), node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 326
def visit_capture_pattern_node(node)
  visit(node.target) << visit(node.value)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 338
def visit_case_match_node(node)
  s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 332
def visit_case_node(node)
  s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 344
def visit_class_node(node)
  name =
    if node.constant_path.is_a?(ConstantReadNode)
      node.name
    else
      visit(node.constant_path)
    end

  if node.body.nil?
    s(node, :class, name, visit(node.superclass))
  elsif node.body.is_a?(StatementsNode)
    compiler = copy_compiler(in_def: false)
    s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
  else
    s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 385
def visit_class_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 379
def visit_class_variable_operator_write_node(node)
  s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.binary_operator, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 391
def visit_class_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 364
def visit_class_variable_read_node(node)
  s(node, :cvar, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 397
def visit_class_variable_target_node(node)
  s(node, class_variable_write_type, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 373
def visit_class_variable_write_node(node)
  s(node, class_variable_write_type, node.name, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 430
def visit_constant_and_write_node(node)
  s(node, :op_asgn_and, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 424
def visit_constant_operator_write_node(node)
  s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.binary_operator, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 436
def visit_constant_or_write_node(node)
  s(node, :op_asgn_or, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 473
def visit_constant_path_and_write_node(node)
  s(node, :op_asgn_and, visit(node.target), visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 448
def visit_constant_path_node(node)
  if node.parent.nil?
    s(node, :colon3, node.name)
  else
    s(node, :colon2, visit(node.parent), node.name)
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 467
def visit_constant_path_operator_write_node(node)
  s(node, :op_asgn, visit(node.target), node.binary_operator, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 479
def visit_constant_path_or_write_node(node)
  s(node, :op_asgn_or, visit(node.target), visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 485
def visit_constant_path_target_node(node)
  inner =
    if node.parent.nil?
      s(node, :colon3, node.child.name)
    else
      s(node, :colon2, visit(node.parent), node.child.name)
    end

  s(node, :const, inner)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 461
def visit_constant_path_write_node(node)
  s(node, :cdecl, visit(node.target), visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 409
def visit_constant_read_node(node)
  s(node, :const, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 442
def visit_constant_target_node(node)
  s(node, :cdecl, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 418
def visit_constant_write_node(node)
  s(node, :cdecl, node.name, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 501
def visit_def_node(node)
  name = node.name_loc.slice.to_sym
  result =
    if node.receiver.nil?
      s(node, :defn, name)
    else
      s(node, :defs, visit(node.receiver), name)
    end

  result.line(node.name_loc.start_line)
  if node.parameters.nil?
    result << s(node, :args).line(node.name_loc.start_line)
  else
    result << visit(node.parameters)
  end

  if node.body.nil?
    result << s(node, :nil)
  elsif node.body.is_a?(StatementsNode)
    compiler = copy_compiler(in_def: true)
    result.concat(node.body.body.map { |child| child.accept(compiler) })
  else
    result << node.body.accept(copy_compiler(in_def: true))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 532
def visit_defined_node(node)
  s(node, :defined, visit(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1146
        def visit_destructured_parameter(node)
  children =
    [*node.lefts, *node.rest, *node.rights].map do |child|
      case child
      when RequiredParameterNode
        visit(child)
      when MultiTargetNode
        visit_destructured_parameter(child)
      when SplatNode
        :"*#{child.expression&.name}"
      else
        raise
      end
    end

  s(node, :masgn).concat(children)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 538
def visit_else_node(node)
  visit(node.statements)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 544
def visit_embedded_statements_node(node)
  result = s(node, :evstr)
  result << visit(node.statements) unless node.statements.nil?
  result
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 552
def visit_embedded_variable_node(node)
  s(node, :evstr, visit(node.variable))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 558
def visit_ensure_node(node)
  node.statements.nil? ? s(node, :nil) : visit(node.statements)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 564
def visit_false_node(node)
  s(node, :false)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 570
def visit_find_pattern_node(node)
  s(node, :find_pat, visit_pattern_constant(node.constant), :"*#{node.left.expression&.name}", *visit_all(node.requireds), :"*#{node.right.expression&.name}")
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 576
def visit_flip_flop_node(node)
  if node.left.is_a?(IntegerNode) && node.right.is_a?(IntegerNode)
    s(node, :lit, Range.new(node.left.value, node.right.value, node.exclude_end?))
  else
    s(node, node.exclude_end? ? :flip3 : :flip2, visit(node.left), visit(node.right))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 586
def visit_float_node(node)
  s(node, :lit, node.value)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 592
def visit_for_node(node)
  s(node, :for, visit(node.collection), visit(node.index), visit(node.statements))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 598
def visit_forwarding_arguments_node(node)
  s(node, :forward_args)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 604
def visit_forwarding_parameter_node(node)
  s(node, :forward_args)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 613
def visit_forwarding_super_node(node)
  visit_block(node, s(node, :zsuper), node.block)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 640
def visit_global_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 634
def visit_global_variable_operator_write_node(node)
  s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.binary_operator, visit(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 646
def visit_global_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 619
def visit_global_variable_read_node(node)
  s(node, :gvar, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 652
def visit_global_variable_target_node(node)
  s(node, :gasgn, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 628
def visit_global_variable_write_node(node)
  s(node, :gasgn, node.name, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 658
def visit_hash_node(node)
  s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 664
def visit_hash_pattern_node(node)
  result = s(node, :hash_pat, visit_pattern_constant(node.constant)).concat(node.elements.flat_map { |element| visit(element) })

  case node.rest
  when AssocSplatNode
    result << s(node.rest, :kwrest, :"**#{node.rest.value&.name}")
  when NoKeywordsParameterNode
    result << visit(node.rest)
  end

  result
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 685
def visit_if_node(node)
  s(node, :if, visit(node.predicate), visit(node.statements), visit(node.consequent))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 690
def visit_imaginary_node(node)
  s(node, :lit, node.value)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 696
def visit_implicit_node(node)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 701
def visit_implicit_rest_node(node)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 706
def visit_in_node(node)
  pattern =
    if node.pattern.is_a?(ConstantPathNode)
      s(node.pattern, :const, visit(node.pattern))
    else
      node.pattern.accept(copy_compiler(in_pattern: true))
    end

  s(node, :in, pattern).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 732
def visit_index_and_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, :"&&", visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 719
def visit_index_operator_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, node.binary_operator, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 745
def visit_index_or_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, :"||", visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 758
def visit_index_target_node(node)
  arguments = visit_all(node.arguments&.arguments || [])
  arguments << visit(node.block) unless node.block.nil?

  s(node, :attrasgn, visit(node.receiver), :[]=).concat(arguments)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 788
def visit_instance_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 782
def visit_instance_variable_operator_write_node(node)
  s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.binary_operator, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 794
def visit_instance_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 767
def visit_instance_variable_read_node(node)
  s(node, :ivar, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 800
def visit_instance_variable_target_node(node)
  s(node, :iasgn, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 776
def visit_instance_variable_write_node(node)
  s(node, :iasgn, node.name, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 806
def visit_integer_node(node)
  s(node, :lit, node.value)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 812
def visit_interpolated_match_last_line_node(node)
  parts = visit_interpolated_parts(node.parts)
  regexp =
    if parts.length == 1
      s(node, :lit, Regexp.new(parts.first, node.options))
    else
      s(node, :dregx).concat(parts).tap do |result|
        options = node.options
        result << options if options != 0
      end
    end

  s(node, :match, regexp)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 865
        def visit_interpolated_parts(parts)
  visited = []
  parts.each do |part|
    result = visit(part)

    if result[0] == :evstr && result[1]
      if result[1][0] == :str
        visited << result[1]
      elsif result[1][0] == :dstr
        visited.concat(result[1][1..-1])
      else
        visited << result
      end
    else
      visited << result
    end
  end

  state = :beginning #: :beginning | :string_content | :interpolated_content

  visited.each_with_object([]) do |result, results|
    case state
    when :beginning
      if result.is_a?(String)
        results << result
        state = :string_content
      elsif result.is_a?(Array) && result[0] == :str
        results << result[1]
        state = :string_content
      else
        results << ""
        results << result
        state = :interpolated_content
      end
    when :string_content
      if result.is_a?(String)
        results[0] << result
      elsif result.is_a?(Array) && result[0] == :str
        results[0] << result[1]
      else
        results << result
        state = :interpolated_content
      end
    else
      results << result
    end
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 829
def visit_interpolated_regular_expression_node(node)
  parts = visit_interpolated_parts(node.parts)

  if parts.length == 1
    s(node, :lit, Regexp.new(parts.first, node.options))
  else
    s(node, :dregx).concat(parts).tap do |result|
      options = node.options
      result << options if options != 0
    end
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 844
def visit_interpolated_string_node(node)
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 851
def visit_interpolated_symbol_node(node)
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 858
def visit_interpolated_x_string_node(node)
  source = node.heredoc? ? node.parts.first : node
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 916
def visit_keyword_hash_node(node)
  s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 925
def visit_keyword_rest_parameter_node(node)
  :"**#{node.name}"
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 930
def visit_lambda_node(node)
  parameters =
    case node.parameters
    when nil, NumberedParametersNode
      s(node, :args)
    else
      visit(node.parameters)
    end

  if node.body.nil?
    s(node, :iter, s(node, :lambda), parameters)
  else
    s(node, :iter, s(node, :lambda), parameters, visit(node.body))
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 973
def visit_local_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 967
def visit_local_variable_operator_write_node(node)
  s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.binary_operator, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 979
def visit_local_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 948
def visit_local_variable_read_node(node)
  if node.name.match?(/^_\d$/)
    s(node, :call, nil, node.name)
  else
    s(node, :lvar, node.name)
  end
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 985
def visit_local_variable_target_node(node)
  s(node, :lasgn, node.name)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 961
def visit_local_variable_write_node(node)
  s(node, :lasgn, node.name, visit_write_value(node.value))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 991
def visit_match_last_line_node(node)
  s(node, :match, s(node, :lit, Regexp.new(node.unescaped, node.options)))
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 997
def visit_match_predicate_node(node)
  s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1003
def visit_match_required_node(node)
  s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
end

          
        

          
            
# File tmp/rubies/ruby-3.4.0-preview1/lib/prism/translation/ruby_parser.rb, line 1009
def visit_match_write_node(node)
  s(node, :match2, visit(node.call.receiver), visit(node.call.arguments.arguments.first))
end