pylint: upgrade to 1.4.0

third_party/pylint/checkers/classes.py

 # 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
+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_attr_protected, node_frame_class, safe_infer, is_builtin_object,
+    decorated_with_property)
+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 \
+              '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',
@@ skipping 66 matching lines @@
               '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 \
+              '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 \
@@ skipping 15 matching lines @@
               '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.')
+              '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
@@ skipping 41 matching lines @@
                  '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({})
+        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('access-member-before-definition', 'attribute-defined-outside-init')
+    @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 cnode.instance_attrs.iteritems():
+        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
@@ skipping 27 matching lines @@
                     # 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())):
+                    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)
@@ skipping 97 matching lines @@
 
     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].setdefault(attrname, []).append(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].setdefault(node.attrname, []).append(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 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):
+        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 accessed.iteritems():
+        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:
-                node.instance_attr_ancestors(attr).next()
+                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:
@@ skipping 11 matching lines @@
                 # 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')):
+                           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
@@ skipping 22 matching lines @@
             # 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',
+                    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',
+                    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])
@@ skipping 41 matching lines @@
                 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),
+                        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]:
@@ skipping 22 matching lines @@
             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 = expr.expr.infer().next()
+                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)
+                        self.add_message('non-parent-init-called',
+                                         node=expr, args=klass.name)
             except astroid.InferenceError:
                 continue
-        for klass, method in not_called_yet.iteritems():
+        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)
+            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, node=method1)
         elif len(method1.args.defaults) < len(refmethod.args.defaults):
             self.add_message('signature-differs', args=class_type, 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] = base_node.igetattr(method).next()
+            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))