class RuboCop::Cop::Lint::RaiseException

end
end
raise Exception # This exception means ‘Gem::Exception`.
def self.foo
module Gem
# good
@example AllowedImplicitNamespaces: [’Gem’]
raise StandardError, ‘Error message here’
# good
raise Exception, ‘Error message here’
# bad
@example
name with an explicit namespace.
‘Exception`. Alternatively, make `Exception` a fully qualified class
prevent the false positive by specifying a namespace to be omitted for
for namespaced `Exception` when a namespace is omitted. This option can
using `AllowedImplicitNamespaces` option. The cop cause a false positive
You can specify a module name that will be an implicit namespace
raising `Exception` class.
This cop checks for `raise` or `fail` statements which are

def allow_implicit_namespaces 

def allow_implicit_namespaces
  cop_config['AllowedImplicitNamespaces'] || []
end

def check(node) 

def check(node)
  lambda do |exception_class, cbase|
    return if cbase.nil? && implicit_namespace?(node)
    add_offense(exception_class) do |corrector|
      prefer_exception = if exception_class.children.first&.cbase_type?
                           '::StandardError'
                         else
                           'StandardError'
                         end
      corrector.replace(exception_class, prefer_exception)
    end
  end
end

def implicit_namespace?(node) 

def implicit_namespace?(node)
  return false unless (parent = node.parent)
  if parent.module_type?
    namespace = parent.identifier.source
    return allow_implicit_namespaces.include?(namespace)
  end
  implicit_namespace?(parent)
end

def on_send(node) 

def on_send(node)
  exception?(node, &check(node)) ||
    exception_new_with_message?(node, &check(node))
end