class RuboCop::Cop::Style::OperatorMethodCall


foo & bar
foo + bar
# good
foo.& bar
foo.+ bar
# bad
@example
`<=‘, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
Checks for redundant dot before operator method call.

def anonymous_forwarding?(argument)

def anonymous_forwarding?(argument)
  return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
  return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
  argument.block_pass_type? && argument.source == '&'
end

def method_call_with_parenthesized_arg?(argument)

Checks for an acceptable case of `foo.+(bar).baz`.
def method_call_with_parenthesized_arg?(argument)
  return false unless argument.parent.parent&.send_type?
  argument.children.first && argument.parent.parenthesized?
end

def on_send(node)

def on_send(node)
  return unless (dot = node.loc.dot)
  return if node.receiver.const_type? || !node.arguments.one?
  _lhs, _op, rhs = *node
  return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
  add_offense(dot) do |corrector|
    wrap_in_parentheses_if_chained(corrector, node)
    corrector.replace(dot, ' ')
  end
end

def wrap_in_parentheses_if_chained(corrector, node)

def wrap_in_parentheses_if_chained(corrector, node)
  return unless node.parent&.call_type?
  operator = node.loc.selector
  ParenthesesCorrector.correct(corrector, node)
  corrector.insert_after(operator, ' ')
  corrector.wrap(node, '(', ')')
end