Index: third_party/pylint/pylint/checkers/classes.py |
diff --git a/third_party/pylint/pylint/checkers/classes.py b/third_party/pylint/pylint/checkers/classes.py |
new file mode 100644 |
index 0000000000000000000000000000000000000000..1a10c3576d7bdb7ca9079c131fcf845012d6b432 |
--- /dev/null |
+++ b/third_party/pylint/pylint/checkers/classes.py |
@@ -0,0 +1,981 @@ |
+# Copyright (c) 2003-2014 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. |
+"""classes checker for Python code |
+""" |
+from __future__ import generators |
+ |
+import sys |
+from collections import defaultdict |
+ |
+import astroid |
+from astroid import YES, Instance, are_exclusive, AssAttr, Class |
+from astroid.bases import Generator, BUILTINS |
+from astroid.inference import InferenceContext |
+ |
+from pylint.interfaces import IAstroidChecker |
+from pylint.checkers import BaseChecker |
+from pylint.checkers.utils import ( |
+ PYMETHODS, overrides_a_method, check_messages, is_attr_private, |
+ is_attr_protected, node_frame_class, safe_infer, is_builtin_object, |
+ decorated_with_property, unimplemented_abstract_methods) |
+import six |
+ |
+if sys.version_info >= (3, 0): |
+ NEXT_METHOD = '__next__' |
+else: |
+ NEXT_METHOD = 'next' |
+ITER_METHODS = ('__iter__', '__getitem__') |
+ |
+def _called_in_methods(func, klass, methods): |
+ """ Check if the func was called in any of the given methods, |
+ belonging to the *klass*. Returns True if so, False otherwise. |
+ """ |
+ if not isinstance(func, astroid.Function): |
+ return False |
+ for method in methods: |
+ try: |
+ infered = klass.getattr(method) |
+ except astroid.NotFoundError: |
+ continue |
+ for infer_method in infered: |
+ for callfunc in infer_method.nodes_of_class(astroid.CallFunc): |
+ try: |
+ bound = next(callfunc.func.infer()) |
+ except (astroid.InferenceError, StopIteration): |
+ continue |
+ if not isinstance(bound, astroid.BoundMethod): |
+ continue |
+ func_obj = bound._proxied |
+ if isinstance(func_obj, astroid.UnboundMethod): |
+ func_obj = func_obj._proxied |
+ if func_obj.name == func.name: |
+ return True |
+ return False |
+ |
+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 |
+ |
+def _is_attribute_property(name, klass): |
+ """ Check if the given attribute *name* is a property |
+ in the given *klass*. |
+ |
+ It will look for `property` calls or for functions |
+ with the given name, decorated by `property` or `property` |
+ subclasses. |
+ Returns ``True`` if the name is a property in the given klass, |
+ ``False`` otherwise. |
+ """ |
+ |
+ try: |
+ attributes = klass.getattr(name) |
+ except astroid.NotFoundError: |
+ return False |
+ property_name = "{0}.property".format(BUILTINS) |
+ for attr in attributes: |
+ try: |
+ infered = next(attr.infer()) |
+ except astroid.InferenceError: |
+ continue |
+ if (isinstance(infered, astroid.Function) and |
+ decorated_with_property(infered)): |
+ return True |
+ if infered.pytype() == property_name: |
+ return True |
+ return False |
+ |
+ |
+MSGS = { |
+ 'F0202': ('Unable to check methods signature (%s / %s)', |
+ 'method-check-failed', |
+ '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 defined in %s line %s hides this method', |
+ 'method-hidden', |
+ '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', |
+ 'access-member-before-definition', |
+ 'Used when an instance member is accessed before it\'s actually\ |
+ assigned.'), |
+ 'W0201': ('Attribute %r defined outside __init__', |
+ 'attribute-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 |
+ 'protected-access', |
+ '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', |
+ 'no-method-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', |
+ 'no-self-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 %s should have %s as first argument', # E0212 |
+ 'bad-classmethod-argument', |
+ 'Used when a class method has a first argument named differently ' |
+ 'than the value specified in valid-classmethod-first-arg option ' |
+ '(default to "cls"), recommended to easily differentiate them ' |
+ 'from regular instance methods.'), |
+ 'C0203': ('Metaclass method %s should have %s as first argument', # E0214 |
+ 'bad-mcs-method-argument', |
+ 'Used when a metaclass method has a first agument named ' |
+ 'differently than the value specified in valid-classmethod-first' |
+ '-arg option (default to "cls"), recommended to easily ' |
+ 'differentiate them from regular instance methods.'), |
+ 'C0204': ('Metaclass class method %s should have %s as first argument', |
+ 'bad-mcs-classmethod-argument', |
+ 'Used when a metaclass class method has a first argument named ' |
+ 'differently than the value specified in valid-metaclass-' |
+ 'classmethod-first-arg option (default to "mcs"), recommended to ' |
+ 'easily differentiate them from regular instance methods.'), |
+ |
+ 'W0211': ('Static method with %r as first argument', |
+ 'bad-staticmethod-argument', |
+ 'Used when a static method has "self" or a value specified in ' |
+ 'valid-classmethod-first-arg option or ' |
+ 'valid-metaclass-classmethod-first-arg option as first argument.' |
+ ), |
+ 'R0201': ('Method could be a function', |
+ 'no-self-use', |
+ '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', |
+ 'interface-is-not-class', |
+ 'Used when a class claims to implement an interface which is not \ |
+ a class.'), |
+ 'E0222': ('Missing method %r from %s interface', |
+ 'missing-interface-method', |
+ 'Used when a method declared in an interface is missing from a \ |
+ class implementing this interface'), |
+ 'W0221': ('Arguments number differs from %s %r method', |
+ 'arguments-differ', |
+ '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 %r method', |
+ 'signature-differs', |
+ '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', |
+ 'abstract-method', |
+ '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 |
+ 'unresolved-interface', |
+ 'Used when a Pylint as failed to find interfaces implemented by \ |
+ a class'), |
+ |
+ |
+ 'W0231': ('__init__ method from base class %r is not called', |
+ 'super-init-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', |
+ 'no-init', |
+ 'Used when a class has no __init__ method, neither its parent \ |
+ classes.'), |
+ 'W0233': ('__init__ method from a non direct base class %r is called', |
+ 'non-parent-init-called', |
+ 'Used when an __init__ method is called on a class which is not \ |
+ in the direct ancestors for the analysed class.'), |
+ 'W0234': ('__iter__ returns non-iterator', |
+ 'non-iterator-returned', |
+ 'Used when an __iter__ method returns something which is not an \ |
+ iterable (i.e. has no `%s` method)' % NEXT_METHOD), |
+ 'E0235': ('__exit__ must accept 3 arguments: type, value, traceback', |
+ 'bad-context-manager', |
+ 'Used when the __exit__ special method, belonging to a \ |
+ context manager, does not accept 3 arguments \ |
+ (type, value, traceback).'), |
+ 'E0236': ('Invalid object %r in __slots__, must contain ' |
+ 'only non empty strings', |
+ 'invalid-slots-object', |
+ 'Used when an invalid (non-string) object occurs in __slots__.'), |
+ 'E0237': ('Assigning to attribute %r not defined in class slots', |
+ 'assigning-non-slot', |
+ 'Used when assigning to an attribute not defined ' |
+ 'in the class slots.'), |
+ 'E0238': ('Invalid __slots__ object', |
+ 'invalid-slots', |
+ 'Used when an invalid __slots__ is found in class. ' |
+ 'Only a string, an iterable or a sequence is permitted.'), |
+ 'E0239': ('Inheriting %r, which is not a class.', |
+ 'inherit-non-class', |
+ 'Used when a class inherits from something which is not a ' |
+ '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__ = (IAstroidChecker,) |
+ |
+ # 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.'} |
+ ), |
+ ('valid-metaclass-classmethod-first-arg', |
+ {'default' : ('mcs',), |
+ 'type' : 'csv', |
+ 'metavar' : '<argument names>', |
+ 'help' : 'List of valid names for the first argument in \ |
+a metaclass class method.'} |
+ ), |
+ ('exclude-protected', |
+ { |
+ 'default': ( |
+ # namedtuple public API. |
+ '_asdict', '_fields', '_replace', '_source', '_make'), |
+ 'type': 'csv', |
+ 'metavar': '<protected access exclusions>', |
+ 'help': ('List of member names, which should be excluded ' |
+ 'from the protected access warning.')} |
+ )) |
+ |
+ 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(defaultdict(list)) |
+ 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 astroid.NotFoundError: |
+ self.add_message('no-init', args=node, node=node) |
+ self._check_slots(node) |
+ self._check_proper_bases(node) |
+ |
+ @check_messages('inherit-non-class') |
+ def _check_proper_bases(self, node): |
+ """ |
+ Detect that a class inherits something which is not |
+ a class or a type. |
+ """ |
+ for base in node.bases: |
+ ancestor = safe_infer(base) |
+ if ancestor in (YES, None): |
+ continue |
+ if (isinstance(ancestor, astroid.Instance) and |
+ ancestor.is_subtype_of('%s.type' % (BUILTINS,))): |
+ continue |
+ if not isinstance(ancestor, astroid.Class): |
+ self.add_message('inherit-non-class', |
+ args=base.as_string(), node=node) |
+ |
+ @check_messages('access-member-before-definition', |
+ 'attribute-defined-outside-init') |
+ 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 not self.linter.is_message_enabled('attribute-defined-outside-init'): |
+ return |
+ defining_methods = self.config.defining_attr_methods |
+ current_module = cnode.root() |
+ for attr, nodes in six.iteritems(cnode.instance_attrs): |
+ # skip nodes which are not in the current module and it may screw up |
+ # the output, while it's not worth it |
+ nodes = [n for n in nodes if not |
+ isinstance(n.statement(), (astroid.Delete, astroid.AugAssign)) |
+ and n.root() is current_module] |
+ if not nodes: |
+ continue # error detected by typechecking |
+ # check if any method attr is defined in is a defining method |
+ if any(node.frame().name in defining_methods |
+ for node in nodes): |
+ continue |
+ |
+ # 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 astroid.NotFoundError: |
+ for node in nodes: |
+ if node.frame().name not in defining_methods: |
+ # If the attribute was set by a callfunc in any |
+ # of the defining methods, then don't emit |
+ # the warning. |
+ if _called_in_methods(node.frame(), cnode, |
+ defining_methods): |
+ continue |
+ self.add_message('attribute-defined-outside-init', |
+ 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 astroid 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 astroid build from living objects |
+ continue |
+ if not isinstance(meth_node, astroid.Function): |
+ continue |
+ self._check_signature(node, meth_node, 'overridden') |
+ break |
+ if node.decorators: |
+ for decorator in node.decorators.nodes: |
+ if isinstance(decorator, astroid.Getattr) and \ |
+ decorator.attrname in ('getter', 'setter', 'deleter'): |
+ # attribute affectation will call this method, not hiding it |
+ return |
+ if isinstance(decorator, astroid.Name) and decorator.name == 'property': |
+ # attribute affectation will either call a setter or raise |
+ # an attribute error, anyway not hiding the function |
+ return |
+ # check if the method is hidden by an attribute |
+ try: |
+ overridden = klass.instance_attr(node.name)[0] # XXX |
+ overridden_frame = overridden.frame() |
+ if (isinstance(overridden_frame, astroid.Function) |
+ and overridden_frame.type == 'method'): |
+ overridden_frame = overridden_frame.parent.frame() |
+ if (isinstance(overridden_frame, Class) |
+ and klass.is_subtype_of(overridden_frame.qname())): |
+ args = (overridden.root().name, overridden.fromlineno) |
+ self.add_message('method-hidden', args=args, node=node) |
+ except astroid.NotFoundError: |
+ pass |
+ |
+ # check non-iterators in __iter__ |
+ if node.name == '__iter__': |
+ self._check_iter(node) |
+ elif node.name == '__exit__': |
+ self._check_exit(node) |
+ |
+ def _check_slots(self, node): |
+ if '__slots__' not in node.locals: |
+ return |
+ for slots in node.igetattr('__slots__'): |
+ # check if __slots__ is a valid type |
+ for meth in ITER_METHODS: |
+ try: |
+ slots.getattr(meth) |
+ break |
+ except astroid.NotFoundError: |
+ continue |
+ else: |
+ self.add_message('invalid-slots', node=node) |
+ continue |
+ |
+ if isinstance(slots, astroid.Const): |
+ # a string, ignore the following checks |
+ continue |
+ if not hasattr(slots, 'itered'): |
+ # we can't obtain the values, maybe a .deque? |
+ continue |
+ |
+ if isinstance(slots, astroid.Dict): |
+ values = [item[0] for item in slots.items] |
+ else: |
+ values = slots.itered() |
+ if values is YES: |
+ return |
+ |
+ for elt in values: |
+ try: |
+ self._check_slots_elt(elt) |
+ except astroid.InferenceError: |
+ continue |
+ |
+ def _check_slots_elt(self, elt): |
+ for infered in elt.infer(): |
+ if infered is YES: |
+ continue |
+ if (not isinstance(infered, astroid.Const) or |
+ not isinstance(infered.value, six.string_types)): |
+ self.add_message('invalid-slots-object', |
+ args=infered.as_string(), |
+ node=elt) |
+ continue |
+ if not infered.value: |
+ self.add_message('invalid-slots-object', |
+ args=infered.as_string(), |
+ node=elt) |
+ |
+ def _check_iter(self, node): |
+ try: |
+ infered = node.infer_call_result(node) |
+ except astroid.InferenceError: |
+ return |
+ |
+ for infered_node in infered: |
+ if (infered_node is YES |
+ or isinstance(infered_node, Generator)): |
+ continue |
+ if isinstance(infered_node, astroid.Instance): |
+ try: |
+ infered_node.local_attr(NEXT_METHOD) |
+ except astroid.NotFoundError: |
+ self.add_message('non-iterator-returned', |
+ node=node) |
+ break |
+ |
+ def _check_exit(self, node): |
+ positional = sum(1 for arg in node.args.args if arg.name != 'self') |
+ if positional < 3 and not node.args.vararg: |
+ self.add_message('bad-context-manager', |
+ node=node) |
+ elif positional > 3: |
+ self.add_message('bad-context-manager', |
+ node=node) |
+ |
+ 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 not self.linter.is_message_enabled('no-self-use'): |
+ 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('no-self-use', 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 |
+ # Check self |
+ if self.is_first_attr(node): |
+ self._accessed[-1][attrname].append(node) |
+ return |
+ if not self.linter.is_message_enabled('protected-access'): |
+ return |
+ |
+ self._check_protected_attribute_access(node) |
+ |
+ def visit_assattr(self, node): |
+ if isinstance(node.ass_type(), astroid.AugAssign) and self.is_first_attr(node): |
+ self._accessed[-1][node.attrname].append(node) |
+ self._check_in_slots(node) |
+ |
+ def _check_in_slots(self, node): |
+ """ Check that the given assattr node |
+ is defined in the class slots. |
+ """ |
+ infered = safe_infer(node.expr) |
+ if infered and isinstance(infered, Instance): |
+ klass = infered._proxied |
+ if '__slots__' not in klass.locals or not klass.newstyle: |
+ return |
+ |
+ slots = klass.slots() |
+ if slots is None: |
+ return |
+ # If any ancestor doesn't use slots, the slots |
+ # defined for this class are superfluous. |
+ if any('__slots__' not in ancestor.locals and |
+ ancestor.name != 'object' |
+ for ancestor in klass.ancestors()): |
+ return |
+ |
+ if not any(slot.value == node.attrname for slot in slots): |
+ # If we have a '__dict__' in slots, then |
+ # assigning any name is valid. |
+ if not any(slot.value == '__dict__' for slot in slots): |
+ if _is_attribute_property(node.attrname, klass): |
+ # Properties circumvent the slots mechanism, |
+ # so we should not emit a warning for them. |
+ return |
+ self.add_message('assigning-non-slot', |
+ args=(node.attrname, ), node=node) |
+ |
+ @check_messages('protected-access') |
+ def visit_assign(self, assign_node): |
+ node = assign_node.targets[0] |
+ if not isinstance(node, AssAttr): |
+ return |
+ |
+ if self.is_first_attr(node): |
+ return |
+ |
+ self._check_protected_attribute_access(node) |
+ |
+ def _check_protected_attribute_access(self, node): |
+ '''Given an attribute access node (set or get), check if attribute |
+ access is legitimate. Call _check_first_attr with node before calling |
+ this method. Valid cases are: |
+ * self._attr in a method or cls._attr in a classmethod. Checked by |
+ _check_first_attr. |
+ * Klass._attr inside "Klass" class. |
+ * Klass2._attr inside "Klass" class when Klass2 is a base class of |
+ Klass. |
+ ''' |
+ attrname = node.attrname |
+ |
+ if (is_attr_protected(attrname) and |
+ attrname not in self.config.exclude_protected): |
+ |
+ klass = node_frame_class(node) |
+ |
+ # 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() |
+ |
+ # We are not in a class, no remaining valid case |
+ if klass is None: |
+ self.add_message('protected-access', node=node, args=attrname) |
+ return |
+ |
+ # If the expression begins with a call to super, that's ok. |
+ if isinstance(node.expr, astroid.CallFunc) and \ |
+ isinstance(node.expr.func, astroid.Name) and \ |
+ node.expr.func.name == 'super': |
+ return |
+ |
+ # We are in a class, one remaining valid cases, Klass._attr inside |
+ # Klass |
+ if not (callee == klass.name or callee in klass.basenames): |
+ # Detect property assignments in the body of the class. |
+ # This is acceptable: |
+ # |
+ # class A: |
+ # b = property(lambda: self._b) |
+ |
+ stmt = node.parent.statement() |
+ try: |
+ if (isinstance(stmt, astroid.Assign) and |
+ (stmt in klass.body or klass.parent_of(stmt)) and |
+ isinstance(stmt.value, astroid.CallFunc) and |
+ isinstance(stmt.value.func, astroid.Name) and |
+ stmt.value.func.name == 'property' and |
+ is_builtin_object(next(stmt.value.func.infer(), None))): |
+ return |
+ except astroid.InferenceError: |
+ pass |
+ self.add_message('protected-access', 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 six.iteritems(accessed): |
+ # deactivate "except doesn't do anything", that's expected |
+ # pylint: disable=W0704 |
+ try: |
+ # is it a class attribute ? |
+ node.local_attr(attr) |
+ # yes, stop here |
+ continue |
+ except astroid.NotFoundError: |
+ pass |
+ # is it an instance attribute of a parent class ? |
+ try: |
+ next(node.instance_attr_ancestors(attr)) |
+ # yes, stop here |
+ continue |
+ except StopIteration: |
+ pass |
+ # is it an instance attribute ? |
+ try: |
+ defstmts = node.instance_attr(attr) |
+ except astroid.NotFoundError: |
+ pass |
+ else: |
+ # filter out augment assignment nodes |
+ defstmts = [stmt for stmt in defstmts if stmt not in nodes] |
+ if not defstmts: |
+ # only augment assignment for this node, no-member should be |
+ # triggered by the typecheck checker |
+ continue |
+ # filter defstmts to only pick the first one when there are |
+ # several assignments in the same scope |
+ scope = defstmts[0].scope() |
+ defstmts = [stmt for i, stmt in enumerate(defstmts) |
+ if i == 0 or stmt.scope() is not scope] |
+ # if there are still more than one, don't attempt to be smarter |
+ # than we can be |
+ 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('access-member-before-definition', |
+ 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 or a metaclass regular method (actually |
+ valid-classmethod-first-arg value) |
+ * 'mcs' for a metaclass class method (actually |
+ valid-metaclass-classmethod-first-arg) |
+ * 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 == 'self' or |
+ first_arg in self.config.valid_classmethod_first_arg or |
+ first_arg in self.config.valid_metaclass_classmethod_first_arg): |
+ self.add_message('bad-staticmethod-argument', args=first, node=node) |
+ return |
+ self._first_attrs[-1] = None |
+ # class / regular method with no args |
+ elif not node.args.args: |
+ self.add_message('no-method-argument', node=node) |
+ # metaclass |
+ elif metaclass: |
+ # metaclass __new__ or classmethod |
+ if node.type == 'classmethod': |
+ self._check_first_arg_config( |
+ first, |
+ self.config.valid_metaclass_classmethod_first_arg, node, |
+ 'bad-mcs-classmethod-argument', node.name) |
+ # metaclass regular method |
+ else: |
+ self._check_first_arg_config( |
+ first, |
+ self.config.valid_classmethod_first_arg, node, |
+ 'bad-mcs-method-argument', |
+ node.name) |
+ # regular class |
+ else: |
+ # class method |
+ if node.type == 'classmethod': |
+ self._check_first_arg_config( |
+ first, |
+ self.config.valid_classmethod_first_arg, node, |
+ 'bad-classmethod-argument', |
+ node.name) |
+ # regular method without self as argument |
+ elif first != 'self': |
+ self.add_message('no-self-argument', node=node) |
+ |
+ def _check_first_arg_config(self, first, config, node, message, |
+ method_name): |
+ if first not in config: |
+ if len(config) == 1: |
+ valid = repr(config[0]) |
+ else: |
+ valid = ', '.join(repr(v) for v in config[:-1]) |
+ valid = '%s or %r' % (valid, config[-1]) |
+ self.add_message(message, args=(method_name, valid), node=node) |
+ |
+ def _check_bases_classes(self, node): |
+ """check that the given class node implements abstract methods from |
+ base classes |
+ """ |
+ def is_abstract(method): |
+ return method.is_abstract(pass_is_abstract=False) |
+ |
+ # check if this class abstract |
+ if class_is_abstract(node): |
+ return |
+ |
+ methods = sorted( |
+ unimplemented_abstract_methods(node, is_abstract).items(), |
+ key=lambda item: item[0], |
+ ) |
+ for name, method in 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 name in node.locals: |
+ # it is redefined as an attribute or with a descriptor |
+ continue |
+ self.add_message('abstract-method', node=node, |
+ args=(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, astroid.Class): |
+ e0221_hack[0] = True |
+ self.add_message('interface-is-not-class', 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 astroid |
+ try: |
+ method = node_method(node, name) |
+ except astroid.NotFoundError: |
+ self.add_message('missing-interface-method', |
+ 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 astroid.InferenceError: |
+ if e0221_hack[0]: |
+ return |
+ implements = Instance(node).getattr('__implements__')[0] |
+ assignment = implements.parent |
+ assert isinstance(assignment, astroid.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('unresolved-interface', 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 self.linter.is_message_enabled('super-init-not-called') and |
+ not self.linter.is_message_enabled('non-parent-init-called')): |
+ 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(astroid.CallFunc): |
+ expr = stmt.func |
+ if not isinstance(expr, astroid.Getattr) \ |
+ or expr.attrname != '__init__': |
+ continue |
+ # skip the test if using super |
+ if isinstance(expr.expr, astroid.CallFunc) and \ |
+ isinstance(expr.expr.func, astroid.Name) and \ |
+ expr.expr.func.name == 'super': |
+ return |
+ try: |
+ klass = next(expr.expr.infer()) |
+ if klass is YES: |
+ continue |
+ # The infered klass can be super(), which was |
+ # assigned to a variable and the `__init__` was called later. |
+ # |
+ # base = super() |
+ # base.__init__(...) |
+ |
+ if (isinstance(klass, astroid.Instance) and |
+ isinstance(klass._proxied, astroid.Class) and |
+ is_builtin_object(klass._proxied) and |
+ klass._proxied.name == 'super'): |
+ return |
+ try: |
+ del not_called_yet[klass] |
+ except KeyError: |
+ if klass not in to_call: |
+ self.add_message('non-parent-init-called', |
+ node=expr, args=klass.name) |
+ except astroid.InferenceError: |
+ continue |
+ for klass, method in six.iteritems(not_called_yet): |
+ if klass.name == 'object' or method.parent.name == 'object': |
+ continue |
+ self.add_message('super-init-not-called', 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, astroid.Function) |
+ and isinstance(refmethod, astroid.Function)): |
+ self.add_message('method-check-failed', |
+ 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 is_attr_private(method1.name): |
+ return |
+ if len(method1.args.args) != len(refmethod.args.args): |
+ self.add_message('arguments-differ', |
+ args=(class_type, method1.name), |
+ node=method1) |
+ elif len(method1.args.defaults) < len(refmethod.args.defaults): |
+ self.add_message('signature-differs', |
+ args=(class_type, method1.name), |
+ node=method1) |
+ |
+ def is_first_attr(self, node): |
+ """Check that attribute lookup name use first attribute variable name |
+ (self for method, cls for classmethod and mcs for metaclass). |
+ """ |
+ return self._first_attrs and isinstance(node.expr, astroid.Name) and \ |
+ node.expr.name == self._first_attrs[-1] |
+ |
+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: |
+ to_call[base_node] = next(base_node.igetattr(method)) |
+ except astroid.InferenceError: |
+ continue |
+ return to_call |
+ |
+ |
+def node_method(node, method_name): |
+ """get astroid 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, astroid.Function): |
+ return n |
+ raise astroid.NotFoundError(method_name) |
+ |
+def register(linter): |
+ """required method to auto register this checker """ |
+ linter.register_checker(ClassChecker(linter)) |