class RuboCop::Cop::Lint::DuplicateMethods

def found_instance_method(node, scope)
  name, = *node
  if scope =~ /\A#<Class:(.*)>\Z/
    found_method(node, "#{Regexp.last_match(1)}.#{name}")
  else
    found_method(node, "#{scope}##{name}")
  end
end

def found_method(node, method_name)
  if @definitions.key?(method_name)
    add_offense(node, :keyword, message_for_dup(node, method_name))
  else
    @definitions[method_name] = source_location(node)
  end
end

def initialize(config = nil, options = nil)
  super
  @definitions = {}
end

def lookup_constant(node, const_name)
  # this method is quite imperfect and can be fooled
  # to do much better, we would need to do global analysis of the whole
  # codebase
  node.each_ancestor(:class, :module, :casgn) do |ancestor|
    namespace, mod_name = *ancestor.defined_module
    loop do
      if mod_name == const_name
        return qualified_name(ancestor.parent_module_name,
                              namespace,
                              mod_name)
      end
      break if namespace.nil?
      namespace, mod_name = *namespace
    end
  end
end

def message_for_dup(node, method_name)
  format(MSG, method_name, @definitions[method_name],
         source_location(node))
end

def on_def(node)
  # if a method definition is inside an if, it is very likely
  # that a different definition is used depending on platform, etc.
  return if node.ancestors.any?(&:if_type?)
  return if possible_dsl?(node)
  return unless (scope = node.parent_module_name)
  found_instance_method(node, scope)
end

def on_defs(node)
  return if node.ancestors.any?(&:if_type?)
  return if possible_dsl?(node)
  receiver, name, = *node
  if receiver.const_type?
    _, const_name = *receiver
    if (qualified = lookup_constant(node, const_name))
      found_method(node, "#{qualified}.#{name}")
    end
  elsif receiver.self_type?
    if (enclosing = node.parent_module_name)
      found_method(node, "#{enclosing}.#{name}")
    end
  end
end

def possible_dsl?(node)
  # DSL methods may evaluate a block in the context of a newly created
  # class or module
  # Assume that if a method definition is inside any block call which
  # we can't identify, it could be a DSL
  node.each_ancestor(:block).any? do |ancestor|
    ancestor.method_name != :class_eval && !ancestor.class_constructor?
  end
end

def qualified_name(enclosing, namespace, mod_name)
  if enclosing != 'Object'
    if namespace
      "#{enclosing}::#{namespace.const_name}::#{mod_name}"
    else
      "#{enclosing}::#{mod_name}"
    end
  elsif namespace
    "#{namespace.const_name}::#{mod_name}"
  else
    mod_name
  end
end

def source_location(node)
  range = node.location.expression
  "#{range.source_buffer.name}:#{range.line}"
end