class Rubocop::Cop::Style::RedundantSelf

otherwise.
We allow uses of ‘self` with operators because it would be awkward
Special cases:
end
self.bar= 1 # Make sure above attr writer is called
def foo
attr_writer :bar
* Calling an attribute writer to prevent an local variable assignment
end
self.bar # resolves name class with local variable
bar = 1
def foo2
end
self.bar # resolves name clash with argument
def foo(bar)
end
:baz
def bar
Example:
messages this way.
with public or protected scope, you cannot send private
Note, with using explicit self you can only send messages
variable.
presence of a method name clash with an argument or a local
* Sending a message to same object with zero arguments in
`self` is only needed when:
This cop checks for redundant uses of `self`.

def allow_self(node) 

def allow_self(node)
  if node.type == :send
    receiver, _method_name, *_args = *node
    @allowed_send_nodes << node if receiver && receiver.type == :self
  end
end

def autocorrect(node) 

def autocorrect(node)
  receiver, _method_name, *_args = *node
  @corrections << lambda do |corrector|
    corrector.remove(receiver.loc.expression)
    corrector.remove(node.loc.dot)
  end
end

def constant_name?(method_name) 

def constant_name?(method_name)
  method_name.match(/^[A-Z]/)
end

def initialize(config = nil, options = nil) 

def initialize(config = nil, options = nil)
  super
  @allowed_send_nodes = []
  @local_variables = []
end

def keyword?(method_name) 

def keyword?(method_name)
  [:alias, :and, :begin, :break, :case, :class, :def, :defined, :do,
   :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
   :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
   :super, :then, :true, :undef, :unless, :until, :when, :while,
   :yield].include?(method_name)
end

def on_args(node) 

def on_args(node)
  node.children.each { |arg| on_argument(arg) }
end

def on_argument(node) 

def on_argument(node)
  name, _ = *node
  @local_variables << name
end

def on_blockarg(node) 

def on_blockarg(node)
  on_argument(node)
end

def on_def(node) 

def on_def(node)
  @local_variables = []
end

def on_defs(node) 

def on_defs(node)
  @local_variables = []
end

def on_lvasgn(node) 

def on_lvasgn(node)
  lhs, _rhs = *node
  @local_variables << lhs
end

def on_op_asgn(node) 

def on_op_asgn(node)
  lhs, _op, _rhs = *node
  allow_self(lhs)
end

def on_or_asgn(node) 

def on_or_asgn(node)
  lhs, _rhs = *node
  allow_self(lhs)
end

def on_send(node) 

def on_send(node)
  receiver, method_name, *_args = *node
  if receiver && receiver.type == :self
    unless operator?(method_name) || keyword?(method_name) ||
        constant_name?(method_name) ||
        @allowed_send_nodes.include?(node) ||
        @local_variables.include?(method_name)
      add_offense(node, :expression)
    end
  end
end

def operator?(method_name) 

def operator?(method_name)
  method_name.to_s =~ /\W/
end