You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
307 lines
13 KiB
Python
307 lines
13 KiB
Python
# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
|
|
# http://www.logilab.fr/ -- mailto:contact@logilab.fr
|
|
# This program is free software; you can redistribute it and/or modify it under
|
|
# the terms of the GNU General Public License as published by the Free Software
|
|
# Foundation; either version 2 of the License, or (at your option) any later
|
|
# version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along with
|
|
# this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
"""exceptions handling (raising, catching, exceptions classes) checker
|
|
"""
|
|
import sys
|
|
|
|
from logilab.common.compat import builtins
|
|
BUILTINS_NAME = builtins.__name__
|
|
import astroid
|
|
from astroid import YES, Instance, unpack_infer
|
|
|
|
from pylint.checkers import BaseChecker
|
|
from pylint.checkers.utils import is_empty, is_raising, check_messages
|
|
from pylint.interfaces import IAstroidChecker
|
|
|
|
def infer_bases(klass):
|
|
""" Fully infer the bases of the klass node.
|
|
|
|
This doesn't use .ancestors(), because we need
|
|
the non-inferable nodes (YES nodes),
|
|
which can't be retrieved from .ancestors()
|
|
"""
|
|
for base in klass.bases:
|
|
try:
|
|
inferit = base.infer().next()
|
|
except astroid.InferenceError:
|
|
continue
|
|
if inferit is YES:
|
|
yield inferit
|
|
else:
|
|
for base in infer_bases(inferit):
|
|
yield base
|
|
|
|
PY3K = sys.version_info >= (3, 0)
|
|
OVERGENERAL_EXCEPTIONS = ('Exception',)
|
|
|
|
MSGS = {
|
|
'E0701': ('Bad except clauses order (%s)',
|
|
'bad-except-order',
|
|
'Used when except clauses are not in the correct order (from the '
|
|
'more specific to the more generic). If you don\'t fix the order, '
|
|
'some exceptions may not be catched by the most specific handler.'),
|
|
'E0702': ('Raising %s while only classes, instances or string are allowed',
|
|
'raising-bad-type',
|
|
'Used when something which is neither a class, an instance or a \
|
|
string is raised (i.e. a `TypeError` will be raised).'),
|
|
'E0703': ('Exception context set to something which is not an '
|
|
'exception, nor None',
|
|
'bad-exception-context',
|
|
'Used when using the syntax "raise ... from ...", '
|
|
'where the exception context is not an exception, '
|
|
'nor None.',
|
|
{'minversion': (3, 0)}),
|
|
'E0710': ('Raising a new style class which doesn\'t inherit from BaseException',
|
|
'raising-non-exception',
|
|
'Used when a new style class which doesn\'t inherit from \
|
|
BaseException is raised.'),
|
|
'E0711': ('NotImplemented raised - should raise NotImplementedError',
|
|
'notimplemented-raised',
|
|
'Used when NotImplemented is raised instead of \
|
|
NotImplementedError'),
|
|
'E0712': ('Catching an exception which doesn\'t inherit from BaseException: %s',
|
|
'catching-non-exception',
|
|
'Used when a class which doesn\'t inherit from \
|
|
BaseException is used as an exception in an except clause.'),
|
|
|
|
'W0701': ('Raising a string exception',
|
|
'raising-string',
|
|
'Used when a string exception is raised.'),
|
|
'W0702': ('No exception type(s) specified',
|
|
'bare-except',
|
|
'Used when an except clause doesn\'t specify exceptions type to \
|
|
catch.'),
|
|
'W0703': ('Catching too general exception %s',
|
|
'broad-except',
|
|
'Used when an except catches a too general exception, \
|
|
possibly burying unrelated errors.'),
|
|
'W0704': ('Except doesn\'t do anything',
|
|
'pointless-except',
|
|
'Used when an except clause does nothing but "pass" and there is\
|
|
no "else" clause.'),
|
|
'W0710': ('Exception doesn\'t inherit from standard "Exception" class',
|
|
'nonstandard-exception',
|
|
'Used when a custom exception class is raised but doesn\'t \
|
|
inherit from the builtin "Exception" class.',
|
|
{'maxversion': (3, 0)}),
|
|
'W0711': ('Exception to catch is the result of a binary "%s" operation',
|
|
'binary-op-exception',
|
|
'Used when the exception to catch is of the form \
|
|
"except A or B:". If intending to catch multiple, \
|
|
rewrite as "except (A, B):"'),
|
|
'W0712': ('Implicit unpacking of exceptions is not supported in Python 3',
|
|
'unpacking-in-except',
|
|
'Python3 will not allow implicit unpacking of exceptions in except '
|
|
'clauses. '
|
|
'See http://www.python.org/dev/peps/pep-3110/',
|
|
{'maxversion': (3, 0)}),
|
|
'W0713': ('Indexing exceptions will not work on Python 3',
|
|
'indexing-exception',
|
|
'Indexing exceptions will not work on Python 3. Use '
|
|
'`exception.args[index]` instead.',
|
|
{'maxversion': (3, 0)}),
|
|
}
|
|
|
|
|
|
if sys.version_info < (3, 0):
|
|
EXCEPTIONS_MODULE = "exceptions"
|
|
else:
|
|
EXCEPTIONS_MODULE = "builtins"
|
|
|
|
class ExceptionsChecker(BaseChecker):
|
|
"""checks for
|
|
* excepts without exception filter
|
|
* type of raise argument : string, Exceptions, other values
|
|
"""
|
|
|
|
__implements__ = IAstroidChecker
|
|
|
|
name = 'exceptions'
|
|
msgs = MSGS
|
|
priority = -4
|
|
options = (('overgeneral-exceptions',
|
|
{'default' : OVERGENERAL_EXCEPTIONS,
|
|
'type' :'csv', 'metavar' : '<comma-separated class names>',
|
|
'help' : 'Exceptions that will emit a warning '
|
|
'when being caught. Defaults to "%s"' % (
|
|
', '.join(OVERGENERAL_EXCEPTIONS),)}
|
|
),
|
|
)
|
|
|
|
@check_messages('raising-string', 'nonstandard-exception', 'raising-bad-type',
|
|
'raising-non-exception', 'notimplemented-raised', 'bad-exception-context')
|
|
def visit_raise(self, node):
|
|
"""visit raise possibly inferring value"""
|
|
# ignore empty raise
|
|
if node.exc is None:
|
|
return
|
|
if PY3K and node.cause:
|
|
try:
|
|
cause = node.cause.infer().next()
|
|
except astroid.InferenceError:
|
|
pass
|
|
else:
|
|
if cause is YES:
|
|
return
|
|
if isinstance(cause, astroid.Const):
|
|
if cause.value is not None:
|
|
self.add_message('bad-exception-context',
|
|
node=node)
|
|
elif (not isinstance(cause, astroid.Class) and
|
|
not inherit_from_std_ex(cause)):
|
|
self.add_message('bad-exception-context',
|
|
node=node)
|
|
expr = node.exc
|
|
if self._check_raise_value(node, expr):
|
|
return
|
|
else:
|
|
try:
|
|
value = unpack_infer(expr).next()
|
|
except astroid.InferenceError:
|
|
return
|
|
self._check_raise_value(node, value)
|
|
|
|
def _check_raise_value(self, node, expr):
|
|
"""check for bad values, string exception and class inheritance
|
|
"""
|
|
value_found = True
|
|
if isinstance(expr, astroid.Const):
|
|
value = expr.value
|
|
if isinstance(value, str):
|
|
self.add_message('raising-string', node=node)
|
|
else:
|
|
self.add_message('raising-bad-type', node=node,
|
|
args=value.__class__.__name__)
|
|
elif (isinstance(expr, astroid.Name) and \
|
|
expr.name in ('None', 'True', 'False')) or \
|
|
isinstance(expr, (astroid.List, astroid.Dict, astroid.Tuple,
|
|
astroid.Module, astroid.Function)):
|
|
self.add_message('raising-bad-type', node=node, args=expr.name)
|
|
elif ((isinstance(expr, astroid.Name) and expr.name == 'NotImplemented')
|
|
or (isinstance(expr, astroid.CallFunc) and
|
|
isinstance(expr.func, astroid.Name) and
|
|
expr.func.name == 'NotImplemented')):
|
|
self.add_message('notimplemented-raised', node=node)
|
|
elif isinstance(expr, astroid.BinOp) and expr.op == '%':
|
|
self.add_message('raising-string', node=node)
|
|
elif isinstance(expr, (Instance, astroid.Class)):
|
|
if isinstance(expr, Instance):
|
|
expr = expr._proxied
|
|
if (isinstance(expr, astroid.Class) and
|
|
not inherit_from_std_ex(expr) and
|
|
expr.root().name != BUILTINS_NAME):
|
|
if expr.newstyle:
|
|
self.add_message('raising-non-exception', node=node)
|
|
else:
|
|
self.add_message('nonstandard-exception', node=node)
|
|
else:
|
|
value_found = False
|
|
else:
|
|
value_found = False
|
|
return value_found
|
|
|
|
@check_messages('unpacking-in-except')
|
|
def visit_excepthandler(self, node):
|
|
"""Visit an except handler block and check for exception unpacking."""
|
|
if isinstance(node.name, (astroid.Tuple, astroid.List)):
|
|
self.add_message('unpacking-in-except', node=node)
|
|
|
|
@check_messages('indexing-exception')
|
|
def visit_subscript(self, node):
|
|
""" Look for indexing exceptions. """
|
|
try:
|
|
for infered in node.value.infer():
|
|
if not isinstance(infered, astroid.Instance):
|
|
continue
|
|
if inherit_from_std_ex(infered):
|
|
self.add_message('indexing-exception', node=node)
|
|
except astroid.InferenceError:
|
|
return
|
|
|
|
@check_messages('bare-except', 'broad-except', 'pointless-except',
|
|
'binary-op-exception', 'bad-except-order',
|
|
'catching-non-exception')
|
|
def visit_tryexcept(self, node):
|
|
"""check for empty except"""
|
|
exceptions_classes = []
|
|
nb_handlers = len(node.handlers)
|
|
for index, handler in enumerate(node.handlers):
|
|
# single except doing nothing but "pass" without else clause
|
|
if is_empty(handler.body) and not node.orelse:
|
|
self.add_message('pointless-except', node=handler.type or handler.body[0])
|
|
if handler.type is None:
|
|
if not is_raising(handler.body):
|
|
self.add_message('bare-except', node=handler)
|
|
# check if a "except:" is followed by some other
|
|
# except
|
|
if index < (nb_handlers - 1):
|
|
msg = 'empty except clause should always appear last'
|
|
self.add_message('bad-except-order', node=node, args=msg)
|
|
|
|
elif isinstance(handler.type, astroid.BoolOp):
|
|
self.add_message('binary-op-exception', node=handler, args=handler.type.op)
|
|
else:
|
|
try:
|
|
excs = list(unpack_infer(handler.type))
|
|
except astroid.InferenceError:
|
|
continue
|
|
for exc in excs:
|
|
# XXX skip other non class nodes
|
|
if exc is YES or not isinstance(exc, astroid.Class):
|
|
continue
|
|
exc_ancestors = [anc for anc in exc.ancestors()
|
|
if isinstance(anc, astroid.Class)]
|
|
for previous_exc in exceptions_classes:
|
|
if previous_exc in exc_ancestors:
|
|
msg = '%s is an ancestor class of %s' % (
|
|
previous_exc.name, exc.name)
|
|
self.add_message('bad-except-order', node=handler.type, args=msg)
|
|
if (exc.name in self.config.overgeneral_exceptions
|
|
and exc.root().name == EXCEPTIONS_MODULE
|
|
and not is_raising(handler.body)):
|
|
self.add_message('broad-except', args=exc.name, node=handler.type)
|
|
|
|
if (not inherit_from_std_ex(exc) and
|
|
exc.root().name != BUILTINS_NAME):
|
|
# try to see if the exception is based on a C based
|
|
# exception, by infering all the base classes and
|
|
# looking for inference errors
|
|
bases = infer_bases(exc)
|
|
fully_infered = all(inferit is not YES
|
|
for inferit in bases)
|
|
if fully_infered:
|
|
self.add_message('catching-non-exception',
|
|
node=handler.type,
|
|
args=(exc.name, ))
|
|
|
|
exceptions_classes += excs
|
|
|
|
|
|
def inherit_from_std_ex(node):
|
|
"""return true if the given class node is subclass of
|
|
exceptions.Exception
|
|
"""
|
|
if node.name in ('Exception', 'BaseException') \
|
|
and node.root().name == EXCEPTIONS_MODULE:
|
|
return True
|
|
for parent in node.ancestors(recurs=False):
|
|
if inherit_from_std_ex(parent):
|
|
return True
|
|
return False
|
|
|
|
def register(linter):
|
|
"""required method to auto register this checker"""
|
|
linter.register_checker(ExceptionsChecker(linter))
|