pylint: upgrade to 1.4.1

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
@@ skipping 12 matching lines @@
 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)
+    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,
@@ skipping 128 matching lines @@
              ),
 
     '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 method',
+    '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 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',
@@ skipping 292 matching lines @@
                 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, str)):
+                    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):
@@ skipping 68 matching lines @@
         """ 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.
@@ skipping 193 matching lines @@
                 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
-        for method in node.methods():
+
+        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 method.name in node.locals:
+            if name in node.locals:
                 # it is redefined as an attribute or with a descriptor
                 continue
-            if method.is_abstract(pass_is_abstract=False):
-                self.add_message('abstract-method', node=node,
-                                 args=(method.name, owner.name))
+            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
@@ skipping 97 matching lines @@
             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)
+            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, node=method1)
+            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
@@ skipping 13 matching lines @@
     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))