class RuboCop::Cop::InternalAffairs::LocationExists


node.loc_is?(:begin, ‘(’)
# good
node.loc.respond_to?(:begin) && node.loc.begin.source == ‘(’
# bad
node.loc_is?(:begin, ‘(’)
# good
node.loc.respond_to?(:begin) && node.loc.begin.is?(‘(’)
# bad
node.loc?(:begin)
# good
node.loc.respond_to?(:begin) && node.loc.begin
# bad
@example
the value.
can be used instead of calling ‘Node#respond_to?` before using
When a node location may not exist, `Node#loc?` or `Node#loc_is?`

def dot(node) 

def dot(node)
  node.parent.loc.dot.source
end

def on_and(node) 

def on_and(node)
  replace_with_loc(node) || replace_with_loc_is(node)
end

def register_offense(node, replacement) 

def register_offense(node, replacement)
  message = format(MSG, replacement: replacement, source: node.source)
  add_offense(node, message: message) do |corrector|
    corrector.replace(node, replacement)
  end
end

def replace_assignment(receiver, location) 

def replace_assignment(receiver, location)
  prefix = replace_receiver(receiver)
  "#{prefix}loc#{dot(receiver)}#{location.value} if #{prefix}loc?(#{location.source})"
end

def replace_receiver(receiver) 

def replace_receiver(receiver)
  return '' unless receiver
  "#{receiver.source}#{dot(receiver)}"
end

def replace_with_loc(node) 

def replace_with_loc(node)
  replaceable_with_loc(node) do |receiver, location|
    if node.parent&.assignment?
      register_offense(node, replace_assignment(receiver, location))
    else
      register_offense(node, replacement(receiver, "loc?(#{location.source})"))
    end
  end
end

def replace_with_loc_is(node) 

def replace_with_loc_is(node)
  replaceable_with_loc_is(node) do |receiver, location, value|
    replacement = replacement(receiver, "loc_is?(#{location.source}, #{value.source})")
    register_offense(node, replacement)
  end
end

def replacement(receiver, rest) 

def replacement(receiver, rest)
  "#{replace_receiver(receiver)}#{rest}"
end