class RuboCop::Cop::Lint::InheritException

C = Class.new(RuntimeError)
class C < RuntimeError; end
# good
C = Class.new(Exception)
class C < Exception; end
# bad
@example EnforcedStyle: runtime_error
C = Class.new(StandardError)
class C < StandardError; end
# good
C = Class.new(Exception)
class C < Exception; end
# bad
@example EnforcedStyle: standard_error (default)
but not ‘Exception` and its subclasses.
exception class handle `StandardError` and its subclasses,
This cop’s autocorrection is unsafe because ‘rescue` that omit
@safety
`RuntimeError` instead.
It is configurable to suggest using either `StandardError` (default) or
Looks for error classes inheriting from `Exception`.

def exception_class?(class_node) 

def exception_class?(class_node)
  class_node.const_name == 'Exception'
end

def inherit_exception_class_with_omitted_namespace?(class_node) 

def inherit_exception_class_with_omitted_namespace?(class_node)
  return false if class_node.parent_class.namespace&.cbase_type?
  class_node.left_siblings.any? do |sibling|
    sibling.respond_to?(:identifier) && exception_class?(sibling.identifier)
  end
end

def message(node) 

def message(node)
  format(MSG, prefer: preferred_base_class, current: node.const_name)
end

def on_class(node) 

def on_class(node)
  return unless node.parent_class && exception_class?(node.parent_class)
  return if inherit_exception_class_with_omitted_namespace?(node)
  message = message(node.parent_class)
  add_offense(node.parent_class, message: message) do |corrector|
    corrector.replace(node.parent_class, preferred_base_class)
  end
end

def on_send(node) 

def on_send(node)
  constant = class_new_call?(node)
  return unless constant && exception_class?(constant)
  message = message(constant)
  add_offense(constant, message: message) do |corrector|
    corrector.replace(constant, preferred_base_class)
  end
end

def preferred_base_class 

def preferred_base_class
  PREFERRED_BASE_CLASS[style]
end