# Copyright (c) 2006-2013 LOGILAB S.A. (Paris, FRANCE).
# http://www.logilab.fr/ -- mailto:[email protected]
#
# 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.
"""try to find more bugs in the code using astroid inference capabilities
"""
import re
import shlex
import astroid
from astroid import InferenceError, NotFoundError, YES, Instance
from astroid.bases import BUILTINS
from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE
from pylint.checkers import BaseChecker
from pylint.checkers.utils import (
safe_infer, is_super,
check_messages, decorated_with_property)
MSGS = {
'E1101': ('%s %r has no %r member',
'no-member',
'Used when a variable is accessed for an unexistent member.',
{'old_names': [('E1103', 'maybe-no-member')]}),
'E1102': ('%s is not callable',
'not-callable',
'Used when an object being called has been inferred to a non \
callable object'),
'E1111': ('Assigning to function call which doesn\'t return',
'assignment-from-no-return',
'Used when an assignment is done on a function call but the \
inferred function doesn\'t return anything.'),
'W1111': ('Assigning to function call which only returns None',
'assignment-from-none',
'Used when an assignment is done on a function call but the \
inferred function returns nothing but None.'),
'E1120': ('No value for argument %s in %s call',
'no-value-for-parameter',
'Used when a function call passes too few arguments.'),
'E1121': ('Too many positional arguments for %s call',
'too-many-function-args',
'Used when a function call passes too many positional \
arguments.'),
'E1123': ('Unexpected keyword argument %r in %s call',
'unexpected-keyword-arg',
'Used when a function call passes a keyword argument that \
doesn\'t correspond to one of the function\'s parameter names.'),
'E1124': ('Argument %r passed by position and keyword in %s call',
'redundant-keyword-arg',
'Used when a function call would result in assigning multiple \
values to a function parameter, one value from a positional \
argument and one from a keyword argument.'),
'E1125': ('Missing mandatory keyword argument %r in %s call',
'missing-kwoa',
('Used when a function call does not pass a mandatory'
' keyword-only argument.'),
{'minversion': (3, 0)}),
'E1126': ('Sequence index is not an int, slice, or instance with __index__',
'invalid-sequence-index',
'Used when a sequence type is indexed with an invalid type. '
'Valid types are ints, slices, and objects with an __index__ '
'method.'),
'E1127': ('Slice index is not an int, None, or instance with __index__',
'invalid-slice-index',
'Used when a slice index is not an integer, None, or an object \
with an __index__ method.'),
}
# builtin sequence types in Python 2 and 3.
SEQUENCE_TYPES = set(['str', 'unicode', 'list', 'tuple', 'bytearray',
'xrange', 'range', 'bytes', 'memoryview'])
def _determine_callable(callable_obj):
# Ordering is important, since BoundMethod is a subclass of UnboundMethod,
# and Function inherits Lambda.
if isinstance(callable_obj, astroid.BoundMethod):
# Bound methods have an extra implicit 'self' argument.
return callable_obj, 1, callable_obj.type
elif isinstance(callable_obj, astroid.UnboundMethod):
return callable_obj, 0, 'unbound method'
elif isinstance(callable_obj, astroid.Function):
return callable_obj, 0, callable_obj.type
elif isinstance(callable_obj, astroid.Lambda):
return callable_obj, 0, 'lambda'
elif isinstance(callable_obj, astroid.Class):
# Class instantiation, lookup __new__ instead.
# If we only find object.__new__, we can safely check __init__
# instead.
try:
# Use the last definition of __new__.
new = callable_obj.local_attr('__new__')[-1]
except astroid.NotFoundError:
new = None
if not new or new.parent.scope().name == 'object':
try:
# Use the last definition of __init__.
callable_obj = callable_obj.local_attr('__init__')[-1]
except astroid.NotFoundError:
# do nothing, covered by no-init.
raise ValueError
else:
callable_obj = new
if not isinstance(callable_obj, astroid.Function):
raise ValueError
# both have an extra implicit 'cls'/'self' argument.
return callable_obj, 1, 'constructor'
else:
raise ValueError
class TypeChecker(BaseChecker):
"""try to find bugs in the code using type inference
"""
__implements__ = (IAstroidChecker,)
# configuration section name
name = 'typecheck'
# messages
msgs = MSGS
priority = -1
# configuration options
options = (('ignore-mixin-members',
{'default' : True, 'type' : 'yn', 'metavar': '<y_or_n>',
'help' : 'Tells whether missing members accessed in mixin \
class should be ignored. A mixin class is detected if its name ends with \
"mixin" (case insensitive).'}
),
('ignored-modules',
{'default': (),
'type': 'csv',
'metavar': '<module names>',
'help': 'List of module names for which member attributes \
should not be checked (useful for modules/projects where namespaces are \
manipulated during runtime and thus existing member attributes cannot be \
deduced by static analysis'},
),
('ignored-classes',
{'default' : ('SQLObject',),
'type' : 'csv',
'metavar' : '<members names>',
'help' : 'List of classes names for which member attributes \
should not be checked (useful for classes with attributes dynamically set).'}
),
('zope',
{'default' : False, 'type' : 'yn', 'metavar': '<y_or_n>',
'help' : 'When zope mode is activated, add a predefined set \
of Zope acquired attributes to generated-members.'}
),
('generated-members',
{'default' : ('REQUEST', 'acl_users', 'aq_parent'),
'type' : 'string',
'metavar' : '<members names>',
'help' : 'List of members which are set dynamically and \
missed by pylint inference system, and so shouldn\'t trigger E0201 when \
accessed. Python regular expressions are accepted.'}
),
)
def open(self):
# do this in open since config not fully initialized in __init__
self.generated_members = list(self.config.generated_members)
if self.config.zope:
self.generated_members.extend(('REQUEST', 'acl_users', 'aq_parent'))
def visit_assattr(self, node):
if isinstance(node.ass_type(), astroid.AugAssign):
self.visit_getattr(node)
def visit_delattr(self, node):
self.visit_getattr(node)
@check_messages('no-member')
def visit_getattr(self, node):
"""check that the accessed attribute exists
to avoid to much false positives for now, we'll consider the code as
correct if a single of the inferred nodes has the accessed attribute.
function/method, super call and metaclasses are ignored
"""
# generated_members may containt regular expressions
# (surrounded by quote `"` and followed by a comma `,`)
# REQUEST,aq_parent,"[a-zA-Z]+_set{1,2}"' =>
# ('REQUEST', 'aq_parent', '[a-zA-Z]+_set{1,2}')
if isinstance(self.config.generated_members, str):
gen = shlex.shlex(self.config.generated_members)
gen.whitespace += ','
gen.wordchars += '[]-+'
self.config.generated_members = tuple(tok.strip('"') for tok in gen)
for pattern in self.config.generated_members:
# attribute is marked as generated, stop here
if re.match(pattern, node.attrname):
return
try:
infered = list(node.expr.infer())
except InferenceError:
return
# list of (node, nodename) which are missing the attribute
missingattr = set()
ignoremim = self.config.ignore_mixin_members
inference_failure = False
for owner in infered:
# skip yes object
if owner is YES:
inference_failure = True
continue
# skip None anyway
if isinstance(owner, astroid.Const) and owner.value is None:
continue
# XXX "super" / metaclass call
if is_super(owner) or getattr(owner, 'type', None) == 'metaclass':
continue
name = getattr(owner, 'name', 'None')
if name in self.config.ignored_classes:
continue
if ignoremim and name[-5:].lower() == 'mixin':
continue
try:
if not [n for n in owner.getattr(node.attrname)
if not isinstance(n.statement(), astroid.AugAssign)]:
missingattr.add((owner, name))
continue
except AttributeError:
# XXX method / function
continue
except NotFoundError:
if isinstance(owner, astroid.Function) and owner.decorators:
continue
if isinstance(owner, Instance) and owner.has_dynamic_getattr():
continue
# explicit skipping of module member access
if owner.root().name in self.config.ignored_modules:
continue
if isinstance(owner, astroid.Class):
# Look up in the metaclass only if the owner is itself
# a class.
# TODO: getattr doesn't return by default members
# from the metaclass, because handling various cases
# of methods accessible from the metaclass itself
# and/or subclasses only is too complicated for little to
# no benefit.
metaclass = owner.metaclass()
try:
if metaclass and metaclass.getattr(node.attrname):
continue
except NotFoundError:
pass
missingattr.add((owner, name))
continue
# stop on the first found
break
else:
# we have not found any node with the attributes, display the
# message for infered nodes
done = set()
for owner, name in missingattr:
if isinstance(owner, Instance):
actual = owner._proxied
else:
actual = owner
if actual in done:
continue
done.add(actual)
confidence = INFERENCE if not inference_failure else INFERENCE_FAILURE
self.add_message('no-member', node=node,
args=(owner.display_type(), name,
node.attrname),
confidence=confidence)
@check_messages('assignment-from-no-return', 'assignment-from-none')
def visit_assign(self, node):
"""check that if assigning to a function call, the function is
possibly returning something valuable
"""
if not isinstance(node.value, astroid.CallFunc):
return
function_node = safe_infer(node.value.func)
# skip class, generator and incomplete function definition
if not (isinstance(function_node, astroid.Function) and
function_node.root().fully_defined()):
return
if function_node.is_generator() \
or function_node.is_abstract(pass_is_abstract=False):
return
returns = list(function_node.nodes_of_class(astroid.Return,
skip_klass=astroid.Function))
if len(returns) == 0:
self.add_message('assignment-from-no-return', node=node)
else:
for rnode in returns:
if not (isinstance(rnode.value, astroid.Const)
and rnode.value.value is None
or rnode.value is None):
break
else:
self.add_message('assignment-from-none', node=node)
def _check_uninferable_callfunc(self, node):
"""
Check that the given uninferable CallFunc node does not
call an actual function.
"""
if not isinstance(node.func, astroid.Getattr):
return
# Look for properties. First, obtain
# the lhs of the Getattr node and search the attribute
# there. If that attribute is a property or a subclass of properties,
# then most likely it's not callable.
# TODO: since astroid doesn't understand descriptors very well
# we will not handle them here, right now.
expr = node.func.expr
klass = safe_infer(expr)
if (klass is None or klass is astroid.YES or
not isinstance(klass, astroid.Instance)):
return
try:
attrs = klass._proxied.getattr(node.func.attrname)
except astroid.NotFoundError:
return
for attr in attrs:
if attr is astroid.YES:
continue
if not isinstance(attr, astroid.Function):
continue
# Decorated, see if it is decorated with a property.
# Also, check the returns and see if they are callable.
if decorated_with_property(attr):
if all(return_node.callable()
for return_node in attr.infer_call_result(node)):
continue
else:
self.add_message('not-callable', node=node,
args=node.func.as_string())
break
@check_messages(*(list(MSGS.keys())))
def visit_callfunc(self, node):
"""check that called functions/methods are inferred to callable objects,
and that the arguments passed to the function match the parameters in
the inferred function's definition
"""
# Build the set of keyword arguments, checking for duplicate keywords,
# and count the positional arguments.
keyword_args = set()
num_positional_args = 0
for arg in node.args:
if isinstance(arg, astroid.Keyword):
keyword_args.add(arg.arg)
else:
num_positional_args += 1
called = safe_infer(node.func)
# only function, generator and object defining __call__ are allowed
if called is not None and not called.callable():
self.add_message('not-callable', node=node,
args=node.func.as_string())
self._check_uninferable_callfunc(node)
try:
called, implicit_args, callable_name = _determine_callable(called)
except ValueError:
# Any error occurred during determining the function type, most of
# those errors are handled by different warnings.
return
num_positional_args += implicit_args
if called.args.args is None:
# Built-in functions have no argument information.
return
if len(called.argnames()) != len(set(called.argnames())):
# Duplicate parameter name (see E9801). We can't really make sense
# of the function call in this case, so just return.
return
# Analyze the list of formal parameters.
num_mandatory_parameters = len(called.args.args) - len(called.args.defaults)
parameters = []
parameter_name_to_index = {}
for i, arg in enumerate(called.args.args):
if isinstance(arg, astroid.Tuple):
name = None
# Don't store any parameter names within the tuple, since those
# are not assignable from keyword arguments.
else:
if isinstance(arg, astroid.Keyword):
name = arg.arg
else:
assert isinstance(arg, astroid.AssName)
# This occurs with:
# def f( (a), (b) ): pass
name = arg.name
parameter_name_to_index[name] = i
if i >= num_mandatory_parameters:
defval = called.args.defaults[i - num_mandatory_parameters]
else:
defval = None
parameters.append([(name, defval), False])
kwparams = {}
for i, arg in enumerate(called.args.kwonlyargs):
if isinstance(arg, astroid.Keyword):
name = arg.arg
else:
assert isinstance(arg, astroid.AssName)
name = arg.name
kwparams[name] = [called.args.kw_defaults[i], False]
# Match the supplied arguments against the function parameters.
# 1. Match the positional arguments.
for i in range(num_positional_args):
if i < len(parameters):
parameters[i][1] = True
elif called.args.vararg is not None:
# The remaining positional arguments get assigned to the *args
# parameter.
break
else:
# Too many positional arguments.
self.add_message('too-many-function-args',
node=node, args=(callable_name,))
break
# 2. Match the keyword arguments.
for keyword in keyword_args:
if keyword in parameter_name_to_index:
i = parameter_name_to_index[keyword]
if parameters[i][1]:
# Duplicate definition of function parameter.
self.add_message('redundant-keyword-arg',
node=node, args=(keyword, callable_name))
else:
parameters[i][1] = True
elif keyword in kwparams:
if kwparams[keyword][1]: # XXX is that even possible?
# Duplicate definition of function parameter.
self.add_message('redundant-keyword-arg', node=node,
args=(keyword, callable_name))
else:
kwparams[keyword][1] = True
elif called.args.kwarg is not None:
# The keyword argument gets assigned to the **kwargs parameter.
pass
else:
# Unexpected keyword argument.
self.add_message('unexpected-keyword-arg', node=node,
args=(keyword, callable_name))
# 3. Match the *args, if any. Note that Python actually processes
# *args _before_ any keyword arguments, but we wait until after
# looking at the keyword arguments so as to make a more conservative
# guess at how many values are in the *args sequence.
if node.starargs is not None:
for i in range(num_positional_args, len(parameters)):
[(name, defval), assigned] = parameters[i]
# Assume that *args provides just enough values for all
# non-default parameters after the last parameter assigned by
# the positional arguments but before the first parameter
# assigned by the keyword arguments. This is the best we can
# get without generating any false positives.
if (defval is not None) or assigned:
break
parameters[i][1] = True
# 4. Match the **kwargs, if any.
if node.kwargs is not None:
for i, [(name, defval), assigned] in enumerate(parameters):
# Assume that *kwargs provides values for all remaining
# unassigned named parameters.
if name is not None:
parameters[i][1] = True
else:
# **kwargs can't assign to tuples.
pass
# Check that any parameters without a default have been assigned
# values.
for [(name, defval), assigned] in parameters:
if (defval is None) and not assigned:
if name is None:
display_name = '<tuple>'
else:
display_name = repr(name)
self.add_message('no-value-for-parameter', node=node,
args=(display_name, callable_name))
for name in kwparams:
defval, assigned = kwparams[name]
if defval is None and not assigned:
self.add_message('missing-kwoa', node=node,
args=(name, callable_name))
@check_messages('invalid-sequence-index')
def visit_extslice(self, node):
# Check extended slice objects as if they were used as a sequence
# index to check if the object being sliced can support them
return self.visit_index(node)
@check_messages('invalid-sequence-index')
def visit_index(self, node):
if not node.parent or not hasattr(node.parent, "value"):
return
# Look for index operations where the parent is a sequence type.
# If the types can be determined, only allow indices to be int,
# slice or instances with __index__.
parent_type = safe_infer(node.parent.value)
if not isinstance(parent_type, (astroid.Class, astroid.Instance)):
return
# Determine what method on the parent this index will use
# The parent of this node will be a Subscript, and the parent of that
# node determines if the Subscript is a get, set, or delete operation.
operation = node.parent.parent
if isinstance(operation, astroid.Assign):
methodname = '__setitem__'
elif isinstance(operation, astroid.Delete):
methodname = '__delitem__'
else:
methodname = '__getitem__'
# Check if this instance's __getitem__, __setitem__, or __delitem__, as
# appropriate to the statement, is implemented in a builtin sequence
# type. This way we catch subclasses of sequence types but skip classes
# that override __getitem__ and which may allow non-integer indices.
try:
methods = parent_type.getattr(methodname)
if methods is astroid.YES:
return
itemmethod = methods[0]
except (astroid.NotFoundError, IndexError):
return
if not isinstance(itemmethod, astroid.Function):
return
if itemmethod.root().name != BUILTINS:
return
if not itemmethod.parent:
return
if itemmethod.parent.name not in SEQUENCE_TYPES:
return
# For ExtSlice objects coming from visit_extslice, no further
# inference is necessary, since if we got this far the ExtSlice
# is an error.
if isinstance(node, astroid.ExtSlice):
index_type = node
else:
index_type = safe_infer(node)
if index_type is None or index_type is astroid.YES:
return
# Constants must be of type int
if isinstance(index_type, astroid.Const):
if isinstance(index_type.value, int):
return
# Instance values must be int, slice, or have an __index__ method
elif isinstance(index_type, astroid.Instance):
if index_type.pytype() in (BUILTINS + '.int', BUILTINS + '.slice'):
return
try:
index_type.getattr('__index__')
return
except astroid.NotFoundError:
pass
# Anything else is an error
self.add_message('invalid-sequence-index', node=node)
@check_messages('invalid-slice-index')
def visit_slice(self, node):
# Check the type of each part of the slice
for index in (node.lower, node.upper, node.step):
if index is None:
continue
index_type = safe_infer(index)
if index_type is None or index_type is astroid.YES:
continue
# Constants must of type int or None
if isinstance(index_type, astroid.Const):
if isinstance(index_type.value, (int, type(None))):
continue
# Instance values must be of type int, None or an object
# with __index__
elif isinstance(index_type, astroid.Instance):
if index_type.pytype() in (BUILTINS + '.int',
BUILTINS + '.NoneType'):
continue
try:
index_type.getattr('__index__')
return
except astroid.NotFoundError:
pass
# Anything else is an error
self.add_message('invalid-slice-index', node=node)
def register(linter):
"""required method to auto register this checker """
linter.register_checker(TypeChecker(linter))
Codebase Browser
chromium