| # Copyright (c) 2006-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. |
| """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)) |
