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.
554 lines
23 KiB
Python
554 lines
23 KiB
Python
# Copyright (c) 2003-2011 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.,
|
|
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
"""classes checker for Python code
|
|
"""
|
|
from __future__ import generators
|
|
|
|
from logilab import astng
|
|
from logilab.astng import YES, Instance, are_exclusive
|
|
|
|
from pylint.interfaces import IASTNGChecker
|
|
from pylint.checkers import BaseChecker
|
|
from pylint.checkers.utils import PYMETHODS, overrides_a_method, check_messages
|
|
|
|
def class_is_abstract(node):
|
|
"""return true if the given class node should be considered as an abstract
|
|
class
|
|
"""
|
|
for method in node.methods():
|
|
if method.parent.frame() is node:
|
|
if method.is_abstract(pass_is_abstract=False):
|
|
return True
|
|
return False
|
|
|
|
|
|
MSGS = {
|
|
'F0202': ('Unable to check methods signature (%s / %s)',
|
|
'Used when PyLint has been unable to check methods signature \
|
|
compatibility for an unexpected reason. Please report this kind \
|
|
if you don\'t make sense of it.'),
|
|
|
|
'E0202': ('An attribute affected in %s line %s hide this method',
|
|
'Used when a class defines a method which is hidden by an '
|
|
'instance attribute from an ancestor class or set by some '
|
|
'client code.'),
|
|
'E0203': ('Access to member %r before its definition line %s',
|
|
'Used when an instance member is accessed before it\'s actually\
|
|
assigned.'),
|
|
'W0201': ('Attribute %r defined outside __init__',
|
|
'Used when an instance attribute is defined outside the __init__\
|
|
method.'),
|
|
|
|
'W0212': ('Access to a protected member %s of a client class', # E0214
|
|
'Used when a protected member (i.e. class member with a name \
|
|
beginning with an underscore) is access outside the class or a \
|
|
descendant of the class where it\'s defined.'),
|
|
|
|
'E0211': ('Method has no argument',
|
|
'Used when a method which should have the bound instance as \
|
|
first argument has no argument defined.'),
|
|
'E0213': ('Method should have "self" as first argument',
|
|
'Used when a method has an attribute different the "self" as\
|
|
first argument. This is considered as an error since this is\
|
|
a so common convention that you shouldn\'t break it!'),
|
|
'C0202': ('Class method should have %s as first argument', # E0212
|
|
'Used when a class method has an attribute different than "cls"\
|
|
as first argument, to easily differentiate them from regular \
|
|
instance methods.'),
|
|
'C0203': ('Metaclass method should have "mcs" as first argument', # E0214
|
|
'Used when a metaclass method has an attribute different the \
|
|
"mcs" as first argument.'),
|
|
|
|
'W0211': ('Static method with %r as first argument',
|
|
'Used when a static method has "self" or "cls" as first argument.'
|
|
),
|
|
'R0201': ('Method could be a function',
|
|
'Used when a method doesn\'t use its bound instance, and so could\
|
|
be written as a function.'
|
|
),
|
|
|
|
'E0221': ('Interface resolved to %s is not a class',
|
|
'Used when a class claims to implement an interface which is not \
|
|
a class.'),
|
|
'E0222': ('Missing method %r from %s interface',
|
|
'Used when a method declared in an interface is missing from a \
|
|
class implementing this interface'),
|
|
'W0221': ('Arguments number differs from %s method',
|
|
'Used when a method has a different number of arguments than in \
|
|
the implemented interface or in an overridden method.'),
|
|
'W0222': ('Signature differs from %s method',
|
|
'Used when a method signature is different than in the \
|
|
implemented interface or in an overridden method.'),
|
|
'W0223': ('Method %r is abstract in class %r but is not overridden',
|
|
'Used when an abstract method (i.e. raise NotImplementedError) is \
|
|
not overridden in concrete class.'
|
|
),
|
|
'F0220': ('failed to resolve interfaces implemented by %s (%s)', # W0224
|
|
'Used when a PyLint as failed to find interfaces implemented by \
|
|
a class'),
|
|
|
|
|
|
'W0231': ('__init__ method from base class %r is not called',
|
|
'Used when an ancestor class method has an __init__ method \
|
|
which is not called by a derived class.'),
|
|
'W0232': ('Class has no __init__ method',
|
|
'Used when a class has no __init__ method, neither its parent \
|
|
classes.'),
|
|
'W0233': ('__init__ method from a non direct base class %r is called',
|
|
'Used when an __init__ method is called on a class which is not \
|
|
in the direct ancestors for the analysed class.'),
|
|
|
|
}
|
|
|
|
|
|
class ClassChecker(BaseChecker):
|
|
"""checks for :
|
|
* methods without self as first argument
|
|
* overridden methods signature
|
|
* access only to existent members via self
|
|
* attributes not defined in the __init__ method
|
|
* supported interfaces implementation
|
|
* unreachable code
|
|
"""
|
|
|
|
__implements__ = (IASTNGChecker,)
|
|
|
|
# configuration section name
|
|
name = 'classes'
|
|
# messages
|
|
msgs = MSGS
|
|
priority = -2
|
|
# configuration options
|
|
options = (('ignore-iface-methods',
|
|
{'default' : (#zope interface
|
|
'isImplementedBy', 'deferred', 'extends', 'names',
|
|
'namesAndDescriptions', 'queryDescriptionFor', 'getBases',
|
|
'getDescriptionFor', 'getDoc', 'getName', 'getTaggedValue',
|
|
'getTaggedValueTags', 'isEqualOrExtendedBy', 'setTaggedValue',
|
|
'isImplementedByInstancesOf',
|
|
# twisted
|
|
'adaptWith',
|
|
# logilab.common interface
|
|
'is_implemented_by'),
|
|
'type' : 'csv',
|
|
'metavar' : '<method names>',
|
|
'help' : 'List of interface methods to ignore, \
|
|
separated by a comma. This is used for instance to not check methods defines \
|
|
in Zope\'s Interface base class.'}
|
|
),
|
|
|
|
('defining-attr-methods',
|
|
{'default' : ('__init__', '__new__', 'setUp'),
|
|
'type' : 'csv',
|
|
'metavar' : '<method names>',
|
|
'help' : 'List of method names used to declare (i.e. assign) \
|
|
instance attributes.'}
|
|
),
|
|
('valid-classmethod-first-arg',
|
|
{'default' : ('cls',),
|
|
'type' : 'csv',
|
|
'metavar' : '<argument names>',
|
|
'help' : 'List of valid names for the first argument in \
|
|
a class method.'}
|
|
),
|
|
|
|
)
|
|
|
|
def __init__(self, linter=None):
|
|
BaseChecker.__init__(self, linter)
|
|
self._accessed = []
|
|
self._first_attrs = []
|
|
self._meth_could_be_func = None
|
|
|
|
def visit_class(self, node):
|
|
"""init visit variable _accessed and check interfaces
|
|
"""
|
|
self._accessed.append({})
|
|
self._check_bases_classes(node)
|
|
self._check_interfaces(node)
|
|
# if not an interface, exception, metaclass
|
|
if node.type == 'class':
|
|
try:
|
|
node.local_attr('__init__')
|
|
except astng.NotFoundError:
|
|
self.add_message('W0232', args=node, node=node)
|
|
|
|
@check_messages('E0203', 'W0201')
|
|
def leave_class(self, cnode):
|
|
"""close a class node:
|
|
check that instance attributes are defined in __init__ and check
|
|
access to existent members
|
|
"""
|
|
# check access to existent members on non metaclass classes
|
|
accessed = self._accessed.pop()
|
|
if cnode.type != 'metaclass':
|
|
self._check_accessed_members(cnode, accessed)
|
|
# checks attributes are defined in an allowed method such as __init__
|
|
if 'W0201' not in self.active_msgs:
|
|
return
|
|
defining_methods = self.config.defining_attr_methods
|
|
for attr, nodes in cnode.instance_attrs.items():
|
|
nodes = [n for n in nodes if not
|
|
isinstance(n.statement(), (astng.Delete, astng.AugAssign))]
|
|
if not nodes:
|
|
continue # error detected by typechecking
|
|
attr_defined = False
|
|
# check if any method attr is defined in is a defining method
|
|
for node in nodes:
|
|
if node.frame().name in defining_methods:
|
|
attr_defined = True
|
|
if not attr_defined:
|
|
# check attribute is defined in a parent's __init__
|
|
for parent in cnode.instance_attr_ancestors(attr):
|
|
attr_defined = False
|
|
# check if any parent method attr is defined in is a defining method
|
|
for node in parent.instance_attrs[attr]:
|
|
if node.frame().name in defining_methods:
|
|
attr_defined = True
|
|
if attr_defined:
|
|
# we're done :)
|
|
break
|
|
else:
|
|
# check attribute is defined as a class attribute
|
|
try:
|
|
cnode.local_attr(attr)
|
|
except astng.NotFoundError:
|
|
self.add_message('W0201', args=attr, node=node)
|
|
|
|
def visit_function(self, node):
|
|
"""check method arguments, overriding"""
|
|
# ignore actual functions
|
|
if not node.is_method():
|
|
return
|
|
klass = node.parent.frame()
|
|
self._meth_could_be_func = True
|
|
# check first argument is self if this is actually a method
|
|
self._check_first_arg_for_type(node, klass.type == 'metaclass')
|
|
if node.name == '__init__':
|
|
self._check_init(node)
|
|
return
|
|
# check signature if the method overloads inherited method
|
|
for overridden in klass.local_attr_ancestors(node.name):
|
|
# get astng for the searched method
|
|
try:
|
|
meth_node = overridden[node.name]
|
|
except KeyError:
|
|
# we have found the method but it's not in the local
|
|
# dictionary.
|
|
# This may happen with astng build from living objects
|
|
continue
|
|
if not isinstance(meth_node, astng.Function):
|
|
continue
|
|
self._check_signature(node, meth_node, 'overridden')
|
|
break
|
|
# check if the method overload an attribute
|
|
try:
|
|
overridden = klass.instance_attr(node.name)[0] # XXX
|
|
args = (overridden.root().name, overridden.fromlineno)
|
|
self.add_message('E0202', args=args, node=node)
|
|
except astng.NotFoundError:
|
|
pass
|
|
|
|
def leave_function(self, node):
|
|
"""on method node, check if this method couldn't be a function
|
|
|
|
ignore class, static and abstract methods, initializer,
|
|
methods overridden from a parent class and any
|
|
kind of method defined in an interface for this warning
|
|
"""
|
|
if node.is_method():
|
|
if node.args.args is not None:
|
|
self._first_attrs.pop()
|
|
if 'R0201' not in self.active_msgs:
|
|
return
|
|
class_node = node.parent.frame()
|
|
if (self._meth_could_be_func and node.type == 'method'
|
|
and not node.name in PYMETHODS
|
|
and not (node.is_abstract() or
|
|
overrides_a_method(class_node, node.name))
|
|
and class_node.type != 'interface'):
|
|
self.add_message('R0201', node=node)
|
|
|
|
def visit_getattr(self, node):
|
|
"""check if the getattr is an access to a class member
|
|
if so, register it. Also check for access to protected
|
|
class member from outside its class (but ignore __special__
|
|
methods)
|
|
"""
|
|
attrname = node.attrname
|
|
if self._first_attrs and isinstance(node.expr, astng.Name) and \
|
|
node.expr.name == self._first_attrs[-1]:
|
|
self._accessed[-1].setdefault(attrname, []).append(node)
|
|
return
|
|
if 'W0212' not in self.active_msgs:
|
|
return
|
|
if attrname[0] == '_' and not attrname == '_' and not (
|
|
attrname.startswith('__') and attrname.endswith('__')):
|
|
# XXX move this in a reusable function
|
|
klass = node.frame()
|
|
while klass is not None and not isinstance(klass, astng.Class):
|
|
if klass.parent is None:
|
|
klass = None
|
|
else:
|
|
klass = klass.parent.frame()
|
|
# XXX infer to be more safe and less dirty ??
|
|
# in classes, check we are not getting a parent method
|
|
# through the class object or through super
|
|
callee = node.expr.as_string()
|
|
if klass is None or not (callee == klass.name or
|
|
callee in klass.basenames
|
|
or (isinstance(node.expr, astng.CallFunc)
|
|
and isinstance(node.expr.func, astng.Name)
|
|
and node.expr.func.name == 'super')):
|
|
self.add_message('W0212', node=node, args=attrname)
|
|
|
|
|
|
def visit_name(self, node):
|
|
"""check if the name handle an access to a class member
|
|
if so, register it
|
|
"""
|
|
if self._first_attrs and (node.name == self._first_attrs[-1] or
|
|
not self._first_attrs[-1]):
|
|
self._meth_could_be_func = False
|
|
|
|
def _check_accessed_members(self, node, accessed):
|
|
"""check that accessed members are defined"""
|
|
# XXX refactor, probably much simpler now that E0201 is in type checker
|
|
for attr, nodes in accessed.items():
|
|
# deactivate "except doesn't do anything", that's expected
|
|
# pylint: disable=W0704
|
|
# is it a class attribute ?
|
|
try:
|
|
node.local_attr(attr)
|
|
# yes, stop here
|
|
continue
|
|
except astng.NotFoundError:
|
|
pass
|
|
# is it an instance attribute of a parent class ?
|
|
try:
|
|
node.instance_attr_ancestors(attr).next()
|
|
# yes, stop here
|
|
continue
|
|
except StopIteration:
|
|
pass
|
|
# is it an instance attribute ?
|
|
try:
|
|
defstmts = node.instance_attr(attr)
|
|
except astng.NotFoundError:
|
|
pass
|
|
else:
|
|
if len(defstmts) == 1:
|
|
defstmt = defstmts[0]
|
|
# check that if the node is accessed in the same method as
|
|
# it's defined, it's accessed after the initial assignment
|
|
frame = defstmt.frame()
|
|
lno = defstmt.fromlineno
|
|
for _node in nodes:
|
|
if _node.frame() is frame and _node.fromlineno < lno \
|
|
and not are_exclusive(_node.statement(), defstmt, ('AttributeError', 'Exception', 'BaseException')):
|
|
self.add_message('E0203', node=_node,
|
|
args=(attr, lno))
|
|
|
|
def _check_first_arg_for_type(self, node, metaclass=0):
|
|
"""check the name of first argument, expect:
|
|
|
|
* 'self' for a regular method
|
|
* 'cls' for a class method
|
|
* 'mcs' for a metaclass
|
|
* not one of the above for a static method
|
|
"""
|
|
# don't care about functions with unknown argument (builtins)
|
|
if node.args.args is None:
|
|
return
|
|
first_arg = node.args.args and node.argnames()[0]
|
|
self._first_attrs.append(first_arg)
|
|
first = self._first_attrs[-1]
|
|
# static method
|
|
if node.type == 'staticmethod':
|
|
if first_arg in ('self', 'cls', 'mcs'):
|
|
self.add_message('W0211', args=first, node=node)
|
|
self._first_attrs[-1] = None
|
|
# class / regular method with no args
|
|
elif not node.args.args:
|
|
self.add_message('E0211', node=node)
|
|
# metaclass method
|
|
elif metaclass:
|
|
if first != 'mcs':
|
|
self.add_message('C0203', node=node)
|
|
# class method
|
|
elif node.type == 'classmethod':
|
|
if first not in self.config.valid_classmethod_first_arg:
|
|
if len(self.config.valid_classmethod_first_arg) == 1:
|
|
valid = repr(self.config.valid_classmethod_first_arg[0])
|
|
else:
|
|
valid = ', '.join(
|
|
repr(v)
|
|
for v in self.config.valid_classmethod_first_arg[:-1])
|
|
valid = '%s or %r' % (
|
|
valid, self.config.valid_classmethod_first_arg[-1])
|
|
self.add_message('C0202', args=valid, node=node)
|
|
# regular method without self as argument
|
|
elif first != 'self':
|
|
self.add_message('E0213', node=node)
|
|
|
|
def _check_bases_classes(self, node):
|
|
"""check that the given class node implements abstract methods from
|
|
base classes
|
|
"""
|
|
# check if this class abstract
|
|
if class_is_abstract(node):
|
|
return
|
|
for method in node.methods():
|
|
owner = method.parent.frame()
|
|
if owner is node:
|
|
continue
|
|
# owner is not this class, it must be a parent class
|
|
# check that the ancestor's method is not abstract
|
|
if method.is_abstract(pass_is_abstract=False):
|
|
self.add_message('W0223', node=node,
|
|
args=(method.name, owner.name))
|
|
|
|
def _check_interfaces(self, node):
|
|
"""check that the given class node really implements declared
|
|
interfaces
|
|
"""
|
|
e0221_hack = [False]
|
|
def iface_handler(obj):
|
|
"""filter interface objects, it should be classes"""
|
|
if not isinstance(obj, astng.Class):
|
|
e0221_hack[0] = True
|
|
self.add_message('E0221', node=node,
|
|
args=(obj.as_string(),))
|
|
return False
|
|
return True
|
|
ignore_iface_methods = self.config.ignore_iface_methods
|
|
try:
|
|
for iface in node.interfaces(handler_func=iface_handler):
|
|
for imethod in iface.methods():
|
|
name = imethod.name
|
|
if name.startswith('_') or name in ignore_iface_methods:
|
|
# don't check method beginning with an underscore,
|
|
# usually belonging to the interface implementation
|
|
continue
|
|
# get class method astng
|
|
try:
|
|
method = node_method(node, name)
|
|
except astng.NotFoundError:
|
|
self.add_message('E0222', args=(name, iface.name),
|
|
node=node)
|
|
continue
|
|
# ignore inherited methods
|
|
if method.parent.frame() is not node:
|
|
continue
|
|
# check signature
|
|
self._check_signature(method, imethod,
|
|
'%s interface' % iface.name)
|
|
except astng.InferenceError:
|
|
if e0221_hack[0]:
|
|
return
|
|
implements = Instance(node).getattr('__implements__')[0]
|
|
assignment = implements.parent
|
|
assert isinstance(assignment, astng.Assign)
|
|
# assignment.expr can be a Name or a Tuple or whatever.
|
|
# Use as_string() for the message
|
|
# FIXME: in case of multiple interfaces, find which one could not
|
|
# be resolved
|
|
self.add_message('F0220', node=implements,
|
|
args=(node.name, assignment.value.as_string()))
|
|
|
|
def _check_init(self, node):
|
|
"""check that the __init__ method call super or ancestors'__init__
|
|
method
|
|
"""
|
|
if not set(('W0231', 'W0233')) & self.active_msgs:
|
|
return
|
|
klass_node = node.parent.frame()
|
|
to_call = _ancestors_to_call(klass_node)
|
|
not_called_yet = dict(to_call)
|
|
for stmt in node.nodes_of_class(astng.CallFunc):
|
|
expr = stmt.func
|
|
if not isinstance(expr, astng.Getattr) \
|
|
or expr.attrname != '__init__':
|
|
continue
|
|
# skip the test if using super
|
|
if isinstance(expr.expr, astng.CallFunc) and \
|
|
isinstance(expr.expr.func, astng.Name) and \
|
|
expr.expr.func.name == 'super':
|
|
return
|
|
try:
|
|
klass = expr.expr.infer().next()
|
|
if klass is YES:
|
|
continue
|
|
try:
|
|
del not_called_yet[klass]
|
|
except KeyError:
|
|
if klass not in to_call:
|
|
self.add_message('W0233', node=expr, args=klass.name)
|
|
except astng.InferenceError:
|
|
continue
|
|
for klass in not_called_yet.keys():
|
|
if klass.name == 'object':
|
|
continue
|
|
self.add_message('W0231', args=klass.name, node=node)
|
|
|
|
def _check_signature(self, method1, refmethod, class_type):
|
|
"""check that the signature of the two given methods match
|
|
|
|
class_type is in 'class', 'interface'
|
|
"""
|
|
if not (isinstance(method1, astng.Function)
|
|
and isinstance(refmethod, astng.Function)):
|
|
self.add_message('F0202', args=(method1, refmethod), node=method1)
|
|
return
|
|
# don't care about functions with unknown argument (builtins)
|
|
if method1.args.args is None or refmethod.args.args is None:
|
|
return
|
|
# if we use *args, **kwargs, skip the below checks
|
|
if method1.args.vararg or method1.args.kwarg:
|
|
return
|
|
if len(method1.args.args) != len(refmethod.args.args):
|
|
self.add_message('W0221', args=class_type, node=method1)
|
|
elif len(method1.args.defaults) < len(refmethod.args.defaults):
|
|
self.add_message('W0222', args=class_type, node=method1)
|
|
|
|
|
|
def _ancestors_to_call(klass_node, method='__init__'):
|
|
"""return a dictionary where keys are the list of base classes providing
|
|
the queried method, and so that should/may be called from the method node
|
|
"""
|
|
to_call = {}
|
|
for base_node in klass_node.ancestors(recurs=False):
|
|
try:
|
|
base_node.local_attr(method)
|
|
to_call[base_node] = 1
|
|
except astng.NotFoundError:
|
|
continue
|
|
return to_call
|
|
|
|
|
|
def node_method(node, method_name):
|
|
"""get astng for <method_name> on the given class node, ensuring it
|
|
is a Function node
|
|
"""
|
|
for n in node.local_attr(method_name):
|
|
if isinstance(n, astng.Function):
|
|
return n
|
|
raise astng.NotFoundError(method_name)
|
|
|
|
def register(linter):
|
|
"""required method to auto register this checker """
|
|
linter.register_checker(ClassChecker(linter))
|