class RuboCop::Cop::Lint::IneffectiveAccessModifier

end
end
end
puts ‘hi’
def method
private
class << self
class C
end
private_class_method :method
end
puts ‘hi’
def self.method
class C
@good
end
end
puts ‘hi’
def self.method
private
class C
@bad
@example
used for that.
singleton methods private/protected. ‘private_class_method` can be
applied to a singleton method. These access modifiers do not make
This cop checks for `private` or `protected` access modifiers which are

def check_node(node) 

def check_node(node)
  if node && node.begin_type?
    clear
    check_scope(node)
    @useless.each do |_name, (defs_node, visibility, modifier)|
      add_offense(defs_node, :keyword,
                  format_message(visibility, modifier))
    end
  end
end

def check_scope(node, cur_vis = :public) 

def check_scope(node, cur_vis = :public)
  node.children.each do |child|
    if (new_vis = access_modifier(child))
      @last_access_modifier = child
      cur_vis = new_vis
    elsif child.defs_type?
      if cur_vis != :public
        _, method_name, = *child
        @useless[method_name] = [child, cur_vis, @last_access_modifier]
      end
    elsif (methods = private_class_method(child))
      # don't warn about defs nodes which are followed by a call to
      # `private_class_method :name`
      # obviously the programmer knows what they are doing
      methods.select(&:sym_type?).each do |sym|
        @useless.delete(sym.children[0])
      end
    elsif child.kwbegin_type?
      cur_vis = check_scope(child, cur_vis)
    end
  end
  cur_vis
end

def clear 

def clear
  @useless = {}
  @last_access_modifier = nil
end

def format_message(visibility, modifier) 

def format_message(visibility, modifier)
  alternative = if visibility == :private
                  ALTERNATIVE_PRIVATE
                else
                  ALTERNATIVE_PROTECTED
                end
  format(MSG, visibility, modifier.location.expression.line, visibility,
         alternative)
end

def on_class(node) 

def on_class(node)
  check_node(node.children[2]) # class body
end

def on_module(node) 

def on_module(node)
  check_node(node.children[1]) # module body
end