Prism::Translation::Parser::Compiler

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 40
def initialize(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false)
  @parser = parser
  @builder = parser.builder
  @source_buffer = parser.source_buffer
  @offset_cache = offset_cache

  @forwarding = forwarding
  @in_destructure = in_destructure
  @in_pattern = in_pattern
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 1943
def copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern)
  Compiler.new(parser, offset_cache, forwarding: forwarding, in_destructure: in_destructure, in_pattern: in_pattern)
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 1950
def find_forwarding(node)
  return [] if node.nil?

  forwarding = []
  forwarding << :* if node.rest.is_a?(RestParameterNode) && node.rest.name.nil?
  forwarding << :** if node.keyword_rest.is_a?(KeywordRestParameterNode) && node.keyword_rest.name.nil?
  forwarding << :& if !node.block.nil? && node.block.name.nil?
  forwarding |= [:&, :"..."] if node.keyword_rest.is_a?(ForwardingParameterNode)

  forwarding
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 1963
def multi_target_elements(node)
  elements = [*node.lefts]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.rights)
  elements
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 1975
def numeric_negate(message_loc, receiver)
  case receiver.type
  when :integer_node, :float_node
    receiver.copy(value: -receiver.value, location: message_loc.join(receiver.location))
  when :rational_node
    receiver.copy(numerator: -receiver.numerator, location: message_loc.join(receiver.location))
  when :imaginary_node
    receiver.copy(numeric: numeric_negate(message_loc, receiver.numeric), location: message_loc.join(receiver.location))
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 1989
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2006
def srange(location)
  Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset]) if location
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2021
def srange_find(start_offset, end_offset, character)
  if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*#{character}/])
    final_offset = start_offset + match.bytesize
    [character, Range.new(source_buffer, offset_cache[final_offset - character.bytesize], offset_cache[final_offset])]
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2011
def srange_offsets(start_offset, end_offset)
  Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2138
def string_nodes_from_interpolation(node, opening)
  node.parts.flat_map do |part|
    if part.type == :string_node && part.content.include?("\n") && part.opening_loc.nil?
      string_nodes_from_line_continuations(part.unescaped, part.content, part.content_loc.start_offset, opening)
    else
      visit(part)
    end
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2150
def string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening)
  unescaped = unescaped.lines
  escaped = escaped.lines
  percent_array = opening&.start_with?("%w", "%W", "%i", "%I")
  regex = opening == "/" || opening&.start_with?("%r")

  # Non-interpolating strings
  if opening&.end_with?("'") || opening&.start_with?("%q", "%s", "%w", "%i")
    current_length = 0
    current_line = +""

    escaped.filter_map.with_index do |escaped_line, index|
      unescaped_line = unescaped.fetch(index, "")
      current_length += escaped_line.bytesize
      current_line << unescaped_line

      # Glue line continuations together. Only %w and %i arrays can contain these.
      if percent_array && escaped_line[/(\\)*\n$/, 1]&.length&.odd?
        next unless index == escaped.count - 1
      end
      s = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_length)])
      start_offset += escaped_line.bytesize
      current_line = +""
      current_length = 0
      s
    end
  else
    escaped_lengths = []
    normalized_lengths = []
    # Keeps track of where an unescaped line should start a new token. An unescaped
    # \n would otherwise be indistinguishable from the actual newline at the end of
    # of the line. The parser gem only emits a new string node at "real" newlines,
    # line continuations don't start a new node as well.
    do_next_tokens = []

    escaped
      .chunk_while { |before, after| before[/(\\*)\r?\n$/, 1]&.length&.odd? || false }
      .each do |lines|
        escaped_lengths << lines.sum(&:bytesize)

        unescaped_lines_count =
          if regex
            0 # Will always be preserved as is
          else
            lines.sum do |line|
              count = line.scan(/(\\*)n/).count { |(backslashes)| backslashes&.length&.odd? }
              count -= 1 if !line.end_with?("\n") && count > 0
              count
            end
          end

        extra = 1
        extra = lines.count if percent_array # Account for line continuations in percent arrays

        normalized_lengths.concat(Array.new(unescaped_lines_count + extra, 0))
        normalized_lengths[-1] = lines.sum { |line| line.bytesize }
        do_next_tokens.concat(Array.new(unescaped_lines_count + extra, false))
        do_next_tokens[-1] = true
      end

    current_line = +""
    current_normalized_length = 0

    emitted_count = 0
    unescaped.filter_map.with_index do |unescaped_line, index|
      current_line << unescaped_line
      current_normalized_length += normalized_lengths.fetch(index, 0)

      if do_next_tokens[index]
        inner_part = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_normalized_length)])
        start_offset += escaped_lengths.fetch(emitted_count, 0)
        current_line = +""
        current_normalized_length = 0
        emitted_count += 1
        inner_part
      else
        nil
      end
    end
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2029
def token(location)
  [location.slice, Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset])] if location
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 59
def visit_alias_global_variable_node(node)
  builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 53
def visit_alias_method_node(node)
  builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 65
def visit_alternation_pattern_node(node)
  builder.match_alt(visit(node.left), token(node.operator_loc), visit(node.right))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 71
def visit_and_node(node)
  builder.logical_op(:and, visit(node.left), token(node.operator_loc), visit(node.right))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 128
def visit_arguments_node(node)
  visit_all(node.arguments)
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 77
def visit_array_node(node)
  if node.opening&.start_with?("%w", "%W", "%i", "%I")
    elements = node.elements.flat_map do |element|
      if element.is_a?(StringNode)
        if element.content.include?("\n")
          string_nodes_from_line_continuations(element.unescaped, element.content, element.content_loc.start_offset, node.opening)
        else
          [builder.string_internal([element.unescaped, srange(element.content_loc)])]
        end
      elsif element.is_a?(InterpolatedStringNode)
        builder.string_compose(
          token(element.opening_loc),
          string_nodes_from_interpolation(element, node.opening),
          token(element.closing_loc)
        )
      else
        [visit(element)]
      end
    end
  else
    elements = visit_all(node.elements)
  end

  builder.array(token(node.opening_loc), elements, token(node.closing_loc))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 105
def visit_array_pattern_node(node)
  elements = [*node.requireds]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.posts)
  visited = visit_all(elements)

  if node.rest.is_a?(ImplicitRestNode)
    visited[-1] = builder.match_with_trailing_comma(visited[-1], token(node.rest.location))
  end

  if node.constant
    if visited.empty?
      builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc)), token(node.closing_loc))
    else
      builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(nil, visited, nil), token(node.closing_loc))
    end
  else
    builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc))
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 134
def visit_assoc_node(node)
  key = node.key

  if  node.value.is_a?(ImplicitNode)
    if in_pattern
      if key.is_a?(SymbolNode)
        if key.opening.nil?
          builder.match_hash_var([key.unescaped, srange(key.location)])
        else
          builder.match_hash_var_from_str(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.value_loc)])], token(key.closing_loc))
        end
      else
        builder.match_hash_var_from_str(token(key.opening_loc), visit_all(key.parts), token(key.closing_loc))
      end
    else
      value = node.value.value

      implicit_value = if value.is_a?(CallNode)
        builder.call_method(nil, nil, [value.name, srange(value.message_loc)])
      elsif value.is_a?(ConstantReadNode)
        builder.const([value.name, srange(key.value_loc)])
      else
        builder.ident([value.name, srange(key.value_loc)]).updated(:lvar)
      end

      builder.pair_keyword([key.unescaped, srange(key)], implicit_value)
    end
  elsif node.operator_loc
    builder.pair(visit(key), token(node.operator_loc), visit(node.value))
  elsif key.is_a?(SymbolNode) && key.opening_loc.nil?
    builder.pair_keyword([key.unescaped, srange(key.location)], visit(node.value))
  else
    parts =
      if key.is_a?(SymbolNode)
        [builder.string_internal([key.unescaped, srange(key.value_loc)])]
      else
        visit_all(key.parts)
      end

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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 182
def visit_assoc_splat_node(node)
  if in_pattern
    builder.match_rest(token(node.operator_loc), token(node.value&.location))
  elsif node.value.nil? && forwarding.include?(:**)
    builder.forwarded_kwrestarg(token(node.operator_loc))
  else
    builder.kwsplat(token(node.operator_loc), visit(node.value))
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 194
def visit_back_reference_read_node(node)
  builder.back_ref(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 200
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.subsequent&.location&.start_offset ||
        node.else_clause&.location&.start_offset ||
        node.ensure_clause&.location&.start_offset ||
        node.end_keyword_loc&.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.subsequent).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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 2034
def visit_block(call, block)
  if block
    parameters = block.parameters
    implicit_parameters = parameters.is_a?(NumberedParametersNode) || parameters.is_a?(ItParametersNode)

    builder.block(
      call,
      token(block.opening_loc),
      if parameters.nil?
        builder.args(nil, [], nil, false)
      elsif implicit_parameters
        visit(parameters)
      else
        builder.args(
          token(parameters.opening_loc),
          if procarg0?(parameters.parameters)
            parameter = parameters.parameters.requireds.first
            visited = parameter.is_a?(RequiredParameterNode) ? visit(parameter) : parameter.accept(copy_compiler(in_destructure: true))
            [builder.procarg0(visited)].concat(visit_all(parameters.locals))
          else
            visit(parameters)
          end,
          token(parameters.closing_loc),
          false
        )
      end,
      visit(block.body),
      token(block.closing_loc)
    )
  else
    call
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 245
def visit_block_argument_node(node)
  builder.block_pass(token(node.operator_loc), visit(node.expression))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 251
def visit_block_local_variable_node(node)
  builder.shadowarg(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 256
def visit_block_node(node)
  raise CompilationError, "Cannot directly compile block nodes"
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 262
def visit_block_parameter_node(node)
  builder.blockarg(token(node.operator_loc), token(node.name_loc))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 267
def visit_block_parameters_node(node)
  [*visit(node.parameters)].concat(visit_all(node.locals))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 276
def visit_break_node(node)
  builder.keyword_cmd(:break, token(node.keyword_loc), nil, visit(node.arguments) || [], nil)
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 381
def visit_call_and_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 288
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

  if node.call_operator_loc.nil?
    case name
    when :-@
      case (receiver = node.receiver).type
      when :integer_node, :float_node, :rational_node, :imaginary_node
        return visit(numeric_negate(node.message_loc, receiver))
      end
    when :!
      return visit_block(builder.not_op(token(node.message_loc), token(node.opening_loc), visit(node.receiver), token(node.closing_loc)), block)
    when :=~
      if (receiver = node.receiver).is_a?(RegularExpressionNode)
        return builder.match_op(visit(receiver), token(node.message_loc), visit(node.arguments.arguments.first))
      end
    when :[]
      return visit_block(builder.index(visit(node.receiver), token(node.opening_loc), visit_all(arguments), token(node.closing_loc)), block)
    when :[]=
      if node.message != "[]=" && node.arguments && block.nil? && !node.safe_navigation?
        arguments = node.arguments.arguments[...-1]
        arguments << node.block if node.block

        return visit_block(
          builder.assign(
            builder.index_asgn(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc),
            ),
            srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, "="),
            visit(node.arguments.arguments.last)
          ),
          block
        )
      end
    end
  end

  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

  visit_block(
    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,
    block
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 362
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.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 400
def visit_call_or_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 419
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 431
def visit_capture_pattern_node(node)
  builder.match_as(visit(node.value), token(node.operator_loc), visit(node.target))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 450
def visit_case_match_node(node)
  builder.case_match(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.else_clause&.else_keyword_loc),
    visit(node.else_clause),
    token(node.end_keyword_loc)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 437
def visit_case_node(node)
  builder.case(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.else_clause&.else_keyword_loc),
    visit(node.else_clause),
    token(node.end_keyword_loc)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 463
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(forwarding: [])),
    token(node.end_keyword_loc)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 502
def visit_class_variable_and_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 492
def visit_class_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.cvar(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 512
def visit_class_variable_or_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 476
def visit_class_variable_read_node(node)
  builder.cvar(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 522
def visit_class_variable_target_node(node)
  builder.assignable(builder.cvar(token(node.location)))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 482
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 553
def visit_constant_and_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 543
def visit_constant_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.const([node.name, srange(node.name_loc)])),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 563
def visit_constant_or_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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 619
def visit_constant_path_and_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 579
def visit_constant_path_node(node)
  if node.parent.nil?
    builder.const_global(
      token(node.delimiter_loc),
      [node.name, srange(node.name_loc)]
    )
  else
    builder.const_fetch(
      visit(node.parent),
      token(node.delimiter_loc),
      [node.name, srange(node.name_loc)]
    )
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 609
def visit_constant_path_operator_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 629
def visit_constant_path_or_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 639
def visit_constant_path_target_node(node)
  builder.assignable(visit_constant_path_node(node))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 599
def visit_constant_path_write_node(node)
  builder.assign(
    builder.assignable(visit(node.target)),
    token(node.operator_loc),
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 528
def visit_constant_read_node(node)
  builder.const([node.name, srange(node.location)])
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 573
def visit_constant_target_node(node)
  builder.assignable(builder.const([node.name, srange(node.location)]))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 537
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 648
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(forwarding: find_forwarding(node.parameters)))
      )
    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(forwarding: find_forwarding(node.parameters)))
      )
    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(forwarding: find_forwarding(node.parameters))),
      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(forwarding: find_forwarding(node.parameters))),
      token(node.end_keyword_loc)
    )
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 695
def visit_defined_node(node)
  # Very weird circumstances here where something like:
  #
  #     defined?
  #     (1)
  #
  # gets parsed in Ruby as having only the `1` expression but in parser
  # it gets parsed as having a begin. In this case we need to synthesize
  # that begin to match parser's behavior.
  if node.lparen_loc && node.keyword_loc.join(node.lparen_loc).slice.include?("\n")
    builder.keyword_cmd(
      :defined?,
      token(node.keyword_loc),
      nil,
      [
        builder.begin(
          token(node.lparen_loc),
          visit(node.value),
          token(node.rparen_loc)
        )
      ],
      nil
    )
  else
    builder.keyword_cmd(
      :defined?,
      token(node.keyword_loc),
      token(node.lparen_loc),
      [visit(node.value)],
      token(node.rparen_loc)
    )
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 731
def visit_else_node(node)
  visit(node.statements)
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 737
def visit_embedded_statements_node(node)
  builder.begin(
    token(node.opening_loc),
    visit(node.statements),
    token(node.closing_loc)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 747
def visit_embedded_variable_node(node)
  visit(node.variable)
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 753
def visit_ensure_node(node)
  raise CompilationError, "Cannot directly compile ensure nodes"
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 759
def visit_false_node(node)
  builder.false(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 765
def visit_find_pattern_node(node)
  elements = [node.left, *node.requireds, node.right]

  if node.constant
    builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.find_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
  else
    builder.find_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
  end
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 777
def visit_float_node(node)
  visit_numeric(node, builder.float([node.value, srange(node.location)]))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 783
def visit_for_node(node)
  builder.for(
    token(node.for_keyword_loc),
    visit(node.index),
    token(node.in_keyword_loc),
    visit(node.collection),
    if (do_keyword_loc = node.do_keyword_loc)
      token(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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 801
def visit_forwarding_arguments_node(node)
  builder.forwarded_args(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 807
def visit_forwarding_parameter_node(node)
  builder.forward_arg(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 816
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 854
def visit_global_variable_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 844
def visit_global_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 864
def visit_global_variable_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 828
def visit_global_variable_read_node(node)
  builder.gvar(token(node.location))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 874
def visit_global_variable_target_node(node)
  builder.assignable(builder.gvar([node.slice, srange(node.location)]))
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 834
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

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 880
def visit_hash_node(node)
  builder.associate(
    token(node.opening_loc),
    visit_all(node.elements),
    token(node.closing_loc)
  )
end

          
        

          
            
# File tmp/rubies/ruby-master/lib/prism/translation/parser/compiler.rb, line 890
def visit_hash_pattern_node(node)
  elements = [*node.elements, *node.rest]

  if node.constant
    builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.hash_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
  else
    builder.hash_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
  end
end