text: # -*- coding: utf-8 -*-
  # Copyright (c) 2006-2016 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
  # Copyright (c) 2012, 2014 Google, Inc.
  # Copyright (c) 2013-2016 Claudiu Popa <pcmanticore@gmail.com>
  # Copyright (c) 2015 Dmitry Pribysh <dmand@yandex.ru>
  # Copyright (c) 2016 Moises Lopez - https://www.vauxoo.com/ <moylop260@vauxoo.com>
  # Copyright (c) 2016 Łukasz Rogalski <rogalski.91@gmail.com>
  
  # Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
  # For details: https://github.com/PyCQA/pylint/blob/master/COPYING
  
  """classes checker for Python code
  """
  from __future__ import generators
  
  import collections
  import sys
  
  import six
  
  import astroid
  from astroid.bases import Generator, BUILTINS
  from astroid.exceptions import InconsistentMroError, DuplicateBasesError
  from astroid import decorators
  from astroid import objects
  from astroid.scoped_nodes import function_to_method
  from pylint.interfaces import IAstroidChecker
  from pylint.checkers import BaseChecker
  from pylint.checkers.utils import (
      PYMETHODS, SPECIAL_METHODS_PARAMS,
      overrides_a_method, check_messages, is_attr_private,
      is_attr_protected, node_frame_class, is_builtin_object,
      decorated_with_property, unimplemented_abstract_methods,
      decorated_with, class_is_abstract,
      safe_infer, has_known_bases, is_iterable, is_comprehension)
  from pylint.utils import get_global_option
  
  
  if sys.version_info >= (3, 0):
      NEXT_METHOD = '__next__'
  else:
      NEXT_METHOD = 'next'
  INVALID_BASE_CLASSES = {'bool', 'range', 'slice', 'memoryview'}
  
  
  # Dealing with useless override detection, with regard
  # to parameters vs arguments
  
  _CallSignature = collections.namedtuple(
      '_CallSignature', 'args kws starred_args starred_kws')
  _ParameterSignature = collections.namedtuple(
      '_ParameterSignature',
      'args kwonlyargs varargs kwargs',
  )
  
  
  def _signature_from_call(call):
      kws = {}
      args = []
      starred_kws = []
      starred_args = []
      for keyword in call.keywords or []:
          arg, value = keyword.arg, keyword.value
          if arg is None and isinstance(value, astroid.Name):
              # Starred node and we are interested only in names,
              # otherwise some transformation might occur for the parameter.
              starred_kws.append(value.name)
          elif isinstance(value, astroid.Name):
              kws[arg] = value.name
          else:
              kws[arg] = None
  
      for arg in call.args:
          if isinstance(arg, astroid.Starred) and isinstance(arg.value, astroid.Name):
              # Positional variadic and a name, otherwise some transformation
              # might have occurred.
              starred_args.append(arg.value.name)
          elif isinstance(arg, astroid.Name):
              args.append(arg.name)
          else:
              args.append(None)
  
      return _CallSignature(args, kws, starred_args, starred_kws)
  
  
  def _signature_from_arguments(arguments):
      kwarg = arguments.kwarg
      vararg = arguments.vararg
      args = [arg.name for arg in arguments.args if arg.name != 'self']
      kwonlyargs = [arg.name for arg in arguments.kwonlyargs]
      return _ParameterSignature(args, kwonlyargs, vararg, kwarg)
  
  
  def _definition_equivalent_to_call(definition, call):
      '''Check if a definition signature is equivalent to a call.'''
      if definition.kwargs:
          same_kw_variadics = definition.kwargs in call.starred_kws
      else:
          same_kw_variadics = not call.starred_kws
      if definition.varargs:
          same_args_variadics = definition.varargs in call.starred_args
      else:
          same_args_variadics = not call.starred_args
      same_kwonlyargs = all(kw in call.kws for kw in definition.kwonlyargs)
      same_args = definition.args == call.args
  
      no_additional_kwarg_arguments = True
      if call.kws:
          for keyword in call.kws:
              is_arg = keyword in call.args
              is_kwonly = keyword in definition.kwonlyargs
              if not is_arg and not is_kwonly:
                  # Maybe this argument goes into **kwargs,
                  # or it is an extraneous argument.
                  # In any case, the signature is different than
                  # the call site, which stops our search.
                  no_additional_kwarg_arguments = False
                  break
  
      return all((
          same_args,
          same_kwonlyargs,
          same_args_variadics,
          same_kw_variadics,
          no_additional_kwarg_arguments,
      ))
  
  # Deal with parameters overridding in two methods.
  
  def _positional_parameters(method):
      positional = method.args.args
      if method.type in ('classmethod', 'method'):
          positional = positional[1:]
      return positional
  
  
  def _has_different_parameters(original, overridden, dummy_parameter_regex):
      zipped = six.moves.zip_longest(original, overridden)
      for original_param, overridden_param in zipped:
          params = (original_param, overridden_param)
          if not all(params):
              return True
  
          names = [param.name for param in params]
          if any(map(dummy_parameter_regex.match, names)):
              continue
          if original_param.name != overridden_param.name:
              return True
      return False
  
  
  def _different_parameters(original, overridden, dummy_parameter_regex):
      """Determine if the two methods have different parameters
  
      They are considered to have different parameters if:
  
         * they have different positional parameters, including different names
  
         * one of the methods is having variadics, while the other is not
  
         * they have different keyword only parameters.
  
      """
      original_parameters = _positional_parameters(original)
      overridden_parameters = _positional_parameters(overridden)
  
      different_positional = _has_different_parameters(
          original_parameters,
          overridden_parameters,
          dummy_parameter_regex)
      different_kwonly = _has_different_parameters(
          original.args.kwonlyargs,
          overridden.args.kwonlyargs,
          dummy_parameter_regex)
      if original.name in PYMETHODS:
          # Ignore the difference for special methods. If the parameter
          # numbers are different, then that is going to be caught by
          # unexpected-special-method-signature.
          # If the names are different, it doesn't matter, since they can't
          # be used as keyword arguments anyway.
          different_positional = different_kwonly = False
  
      # Both or none should have extra variadics, otherwise the method
      # loses or gains capabilities that are not reflected into the parent method,
      # leading to potential inconsistencies in the code.
      different_kwarg = sum(
          1 for param in (original.args.kwarg, overridden.args.kwarg)
          if not param) == 1
      different_vararg = sum(
          1 for param in (original.args.vararg, overridden.args.vararg)
          if not param) == 1
  
      return any((
          different_positional,
          different_kwarg,
          different_vararg,
          different_kwonly
      ))
  
  
  def _is_invalid_base_class(cls):
      return cls.name in INVALID_BASE_CLASSES and is_builtin_object(cls)
  
  
  def _has_data_descriptor(cls, attr):
      attributes = cls.getattr(attr)
      for attribute in attributes:
          try:
              for inferred in attribute.infer():
                  if isinstance(inferred, astroid.Instance):
                      try:
                          inferred.getattr('__get__')
                          inferred.getattr('__set__')
                      except astroid.NotFoundError:
                          continue
                      else:
                          return True
          except astroid.InferenceError:
              # Can't infer, avoid emitting a false positive in this case.
              return True
      return False
  
  
  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.FunctionDef):
          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.Call):
                  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 _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.FunctionDef) and
                  decorated_with_property(infered)):
              return True
          if infered.pytype() == property_name:
              return True
      return False
  
  
  def _has_bare_super_call(fundef_node):
      for call in fundef_node.nodes_of_class(astroid.Call):
          func = call.func
          if (isinstance(func, astroid.Name) and
                  func.name == 'super' and
                  not call.args):
              return True
      return False
  
  
  def _safe_infer_call_result(node, caller, context=None):
      """
      Safely infer the return value of a function.
  
      Returns None if inference failed or if there is some ambiguity (more than
      one node has been inferred). Otherwise returns infered value.
      """
      try:
          inferit = node.infer_call_result(caller, context=context)
          value = next(inferit)
      except astroid.InferenceError:
          return  # inference failed
      except StopIteration:
          return  # no values infered
      try:
          next(inferit)
          return  # there is ambiguity on the inferred node
      except astroid.InferenceError:
          return  # there is some kind of ambiguity
      except StopIteration:
          return value
  
  
  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',
                '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',
                'bad-mcs-method-argument',
                'Used when a metaclass 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.'),
      '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.'
               ),
      'W0221': ('Parameters differ 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.'
               ),
      '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.'),
      'W0235': ('Useless super delegation in method %r',
                'useless-super-delegation',
                'Used whenever we can detect that an overridden method is useless, '
                'relying on super() delegation to do the same thing as another method '
                'from the MRO.'),
      '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.'),
      'E0240': ('Inconsistent method resolution order for class %r',
                'inconsistent-mro',
                'Used when a class has an inconsistent method resolution order.'),
      'E0241': ('Duplicate bases for class %r',
                'duplicate-bases',
                'Used when a class has duplicate bases.'),
      'R0202': ('Consider using a decorator instead of calling classmethod',
                'no-classmethod-decorator',
                'Used when a class method is defined without using the decorator '
                'syntax.'),
      'R0203': ('Consider using a decorator instead of calling staticmethod',
                'no-staticmethod-decorator',
                'Used when a static method is defined without using the decorator '
                'syntax.'),
      'C0205': ('Class __slots__ should be a non-string iterable',
                'single-string-used-for-slots',
                'Used when a class __slots__ is a simple string, rather '
                'than an iterable.'),
      }
  
  
  class ScopeAccessMap(object):
      """Store the accessed variables per scope."""
  
      def __init__(self):
          self._scopes = collections.defaultdict(
              lambda: collections.defaultdict(list)
          )
  
      def set_accessed(self, node):
          """Set the given node as accessed."""
  
          frame = node_frame_class(node)
          if frame is None:
              # The node does not live in a class.
              return
          self._scopes[frame][node.attrname].append(node)
  
      def accessed(self, scope):
          """Get the accessed variables for the given scope."""
          return self._scopes.get(scope, {})
  
  
  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
      * unreachable code
      """
  
      __implements__ = (IAstroidChecker,)
  
      # configuration section name
      name = 'classes'
      # messages
      msgs = MSGS
      priority = -2
      # configuration options
      options = (('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 = ScopeAccessMap()
          self._first_attrs = []
          self._meth_could_be_func = None
  
      @decorators.cachedproperty
      def _dummy_rgx(self):
          return get_global_option(
              self, 'dummy-variables-rgx', default=None)
  
      @decorators.cachedproperty
      def _ignore_mixin(self):
          return get_global_option(
              self, 'ignore-mixin-members', default=True)
  
      def visit_classdef(self, node):
          """init visit variable _accessed
          """
          self._check_bases_classes(node)
          # if not an exception or a metaclass
          if node.type == 'class' and has_known_bases(node):
              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)
          self._check_consistent_mro(node)
  
      def _check_consistent_mro(self, node):
          """Detect that a class has a consistent mro or duplicate bases."""
          try:
              node.mro()
          except InconsistentMroError:
              self.add_message('inconsistent-mro', args=node.name, node=node)
          except DuplicateBasesError:
              self.add_message('duplicate-bases', args=node.name, node=node)
          except NotImplementedError:
              # Old style class, there's no mro so don't do anything.
              pass
  
      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 (astroid.YES, None):
                  continue
              if (isinstance(ancestor, astroid.Instance) and
                      ancestor.is_subtype_of('%s.type' % (BUILTINS,))):
                  continue
  
              if (not isinstance(ancestor, astroid.ClassDef) or
                      _is_invalid_base_class(ancestor)):
                  self.add_message('inherit-non-class',
                                   args=base.as_string(), node=node)
  
      def leave_classdef(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
          if self._ignore_mixin and cnode.name[-5:].lower() == 'mixin':
              # We are in a mixin class. No need to try to figure out if
              # something is missing, since it is most likely that it will
              # miss.
              return
  
          accessed = self._accessed.accessed(cnode)
          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_functiondef(self, node):
          """check method arguments, overriding"""
          # ignore actual functions
          if not node.is_method():
              return
  
          self._check_useless_super_delegation(node)
  
          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.FunctionDef):
                  continue
              self._check_signature(node, meth_node, 'overridden', klass)
              break
          if node.decorators:
              for decorator in node.decorators.nodes:
                  if isinstance(decorator, astroid.Attribute) 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.FunctionDef)
                      and overridden_frame.type == 'method'):
                  overridden_frame = overridden_frame.parent.frame()
              if (isinstance(overridden_frame, astroid.ClassDef)
                      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
  
      visit_asyncfunctiondef = visit_functiondef
  
      def _check_useless_super_delegation(self, function):
          '''Check if the given function node is an useless method override
  
          We consider it *useless* if it uses the super() builtin, but having
          nothing additional whatsoever than not implementing the method at all.
          If the method uses super() to delegate an operation to the rest of the MRO,
          and if the method called is the same as the current one, the arguments
          passed to super() are the same as the parameters that were passed to
          this method, then the method could be removed altogether, by letting
          other implementation to take precedence.
          '''
  
          if not function.is_method():
              return
  
          if function.decorators:
              # With decorators is a change of use
              return
  
          body = function.body
          if len(body) != 1:
              # Multiple statements, which means this overridden method
              # could do multiple things we are not aware of.
              return
  
          statement = body[0]
          if not isinstance(statement, (astroid.Expr, astroid.Return)):
              # Doing something else than what we are interested into.
              return
  
          call = statement.value
          if not isinstance(call, astroid.Call):
              return
          if not isinstance(call.func, astroid.Attribute):
              # Not a super() attribute access.
              return
  
          # Should be a super call.
          try:
              super_call = next(call.func.expr.infer())
          except astroid.InferenceError:
              return
          else:
              if not isinstance(super_call, objects.Super):
                  return
  
          # The name should be the same.
          if call.func.attrname != function.name:
              return
  
          # Should be a super call with the MRO pointer being the current class
          # and the type being the current instance.
          current_scope = function.parent.scope()
          if super_call.mro_pointer != current_scope:
              return
          if not isinstance(super_call.type, astroid.Instance):
              return
          if super_call.type.name != current_scope.name:
              return
  
          # Detect if the parameters are the same as the call's arguments.
          params = _signature_from_arguments(function.args)
          args = _signature_from_call(call)
          if _definition_equivalent_to_call(params, args):
              self.add_message('useless-super-delegation', node=function,
                               args=(function.name, ))
  
      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
              if slots is astroid.YES:
                  continue
              if not is_iterable(slots) and not is_comprehension(slots):
                  self.add_message('invalid-slots', node=node)
                  continue
  
              if isinstance(slots, astroid.Const):
                  # a string, ignore the following checks
                  self.add_message('single-string-used-for-slots', node=node)
                  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 astroid.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 astroid.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 leave_functiondef(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.
          """
          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 node.name not in PYMETHODS
                      and not (node.is_abstract() or
                               overrides_a_method(class_node, node.name) or
                               decorated_with_property(node) or
                               (six.PY3 and _has_bare_super_call(node)))):
                  self.add_message('no-self-use', node=node)
  
      def visit_attribute(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)
          """
          # Check self
          if self._uses_mandatory_method_param(node):
              self._accessed.set_accessed(node)
              return
          if not self.linter.is_message_enabled('protected-access'):
              return
  
          self._check_protected_attribute_access(node)
  
      def visit_assignattr(self, node):
          if (isinstance(node.assign_type(), astroid.AugAssign) and
                  self._uses_mandatory_method_param(node)):
              self._accessed.set_accessed(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, astroid.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
                      if (node.attrname in klass.locals
                              and _has_data_descriptor(klass, node.attrname)):
                          # Descriptors circumvent the slots mechanism as well.
                          return
                      self.add_message('assigning-non-slot',
                                       args=(node.attrname, ), node=node)
  
      @check_messages('protected-access', 'no-classmethod-decorator',
                      'no-staticmethod-decorator')
      def visit_assign(self, assign_node):
          self._check_classmethod_declaration(assign_node)
          node = assign_node.targets[0]
          if not isinstance(node, astroid.AssignAttr):
              return
  
          if self._uses_mandatory_method_param(node):
              return
          self._check_protected_attribute_access(node)
  
      def _check_classmethod_declaration(self, node):
          """Checks for uses of classmethod() or staticmethod()
  
          When a @classmethod or @staticmethod decorator should be used instead.
          A message will be emitted only if the assignment is at a class scope
          and only if the classmethod's argument belongs to the class where it
          is defined.
          `node` is an assign node.
          """
          if not isinstance(node.value, astroid.Call):
              return
  
          # check the function called is "classmethod" or "staticmethod"
          func = node.value.func
          if (not isinstance(func, astroid.Name) or
                  func.name not in ('classmethod', 'staticmethod')):
              return
  
          msg = ('no-classmethod-decorator' if func.name == 'classmethod' else
                 'no-staticmethod-decorator')
          # assignment must be at a class scope
          parent_class = node.scope()
          if not isinstance(parent_class, astroid.ClassDef):
              return
  
          # Check if the arg passed to classmethod is a class member
          classmeth_arg = node.value.args[0]
          if not isinstance(classmeth_arg, astroid.Name):
              return
  
          method_name = classmeth_arg.name
          if any(method_name == member.name
                 for member in parent_class.mymethods()):
              self.add_message(msg, node=node.targets[0])
  
      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.Call) and \
                 isinstance(node.expr.func, astroid.Name) and \
                 node.expr.func.name == 'super':
                  return
  
              # If the expression begins with a call to type(self), that's ok.
              if self._is_type_self_call(node.expr):
                  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()
                  if (isinstance(stmt, astroid.Assign)
                          and len(stmt.targets) == 1
                          and isinstance(stmt.targets[0], astroid.AssignName)):
                      name = stmt.targets[0].name
                      if _is_attribute_property(name, klass):
                          return
  
                  self.add_message('protected-access', node=node, args=attrname)
  
      def _is_type_self_call(self, expr):
          return (isinstance(expr, astroid.Call) and
                  isinstance(expr.func, astroid.Name) and
                  expr.func.name == 'type' and len(expr.args) == 1 and
                  self._is_mandatory_method_param(expr.args[0]))
  
      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
          excs = ('AttributeError', 'Exception', 'BaseException')
          for attr, nodes in six.iteritems(accessed):
              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 astroid.are_exclusive(_node.statement(), defstmt, excs):
                              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_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.Call):
              expr = stmt.func
              if not isinstance(expr, astroid.Attribute) \
                     or expr.attrname != '__init__':
                  continue
              # skip the test if using super
              if isinstance(expr.expr, astroid.Call) and \
                     isinstance(expr.expr.func, astroid.Name) and \
                 expr.expr.func.name == 'super':
                  return
              try:
                  for klass in expr.expr.infer():
                      if klass is astroid.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.ClassDef) and
                              is_builtin_object(klass._proxied) and
                              klass._proxied.name == 'super'):
                          return
                      elif isinstance(klass, objects.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):
              cls = node_frame_class(method)
              if klass.name == 'object' or (cls and cls.name == 'object'):
                  continue
              self.add_message('super-init-not-called', args=klass.name, node=node)
  
      def _check_signature(self, method1, refmethod, class_type, cls):
          """check that the signature of the two given methods match
          """
          if not (isinstance(method1, astroid.FunctionDef)
                  and isinstance(refmethod, astroid.FunctionDef)):
              self.add_message('method-check-failed',
                               args=(method1, refmethod), node=method1)
              return
  
          instance = cls.instantiate_class()
          method1 = function_to_method(method1, instance)
          refmethod = function_to_method(refmethod, instance)
  
          # Don't care about functions with unknown argument (builtins).
          if method1.args.args is None or refmethod.args.args is None:
              return
  
          # Ignore private to class methods.
          if is_attr_private(method1.name):
              return
          # Ignore setters, they have an implicit extra argument,
          # which shouldn't be taken in consideration.
          if method1.decorators:
              for decorator in method1.decorators.nodes:
                  if (isinstance(decorator, astroid.Attribute) and
                          decorator.attrname == 'setter'):
                      return
  
          if _different_parameters(
                  refmethod, method1,
                  dummy_parameter_regex=self._dummy_rgx):
              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 _uses_mandatory_method_param(self, node):
          """Check that attribute lookup name use first attribute variable name
  
          Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
          """
          return self._is_mandatory_method_param(node.expr)
  
      def _is_mandatory_method_param(self, node):
          """Check if astroid.Name corresponds to first attribute variable name
  
          Name is `self` for method, `cls` for classmethod and `mcs` for metaclass.
          """
          return (self._first_attrs and isinstance(node, astroid.Name)
                  and node.name == self._first_attrs[-1])
  
  
  class SpecialMethodsChecker(BaseChecker):
      """Checker which verifies that special methods
      are implemented correctly.
      """
      __implements__ = (IAstroidChecker, )
      name = 'classes'
      msgs = {
          'E0301': ('__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,
                    {'old_names': [('W0234', 'non-iterator-returned'),
                                   ('E0234', 'non-iterator-returned')]}),
          'E0302': ('The special method %r expects %s param(s), %d %s given',
                    'unexpected-special-method-signature',
                    'Emitted when a special method was defined with an '
                    'invalid number of parameters. If it has too few or '
                    'too many, it might not work at all.',
                    {'old_names': [('E0235', 'bad-context-manager')]}),
          'E0303': ('__len__ does not return non-negative integer',
                    'invalid-length-returned',
                    'Used when an __len__ method returns something which is not a '
                    'non-negative integer', {}),
      }
      priority = -2
  
      @check_messages('unexpected-special-method-signature',
                      'non-iterator-returned', 'invalid-length-returned')
      def visit_functiondef(self, node):
          if not node.is_method():
              return
          if node.name == '__iter__':
              self._check_iter(node)
          if node.name == '__len__':
              self._check_len(node)
          if node.name in PYMETHODS:
              self._check_unexpected_method_signature(node)
  
      visit_asyncfunctiondef = visit_functiondef
  
      def _check_unexpected_method_signature(self, node):
          expected_params = SPECIAL_METHODS_PARAMS[node.name]
  
          if expected_params is None:
              # This can support a variable number of parameters.
              return
          if not node.args.args and not node.args.vararg:
              # Method has no parameter, will be caught
              # by no-method-argument.
              return
  
          if decorated_with(node, [BUILTINS + ".staticmethod"]):
              # We expect to not take in consideration self.
              all_args = node.args.args
          else:
              all_args = node.args.args[1:]
          mandatory = len(all_args) - len(node.args.defaults)
          optional = len(node.args.defaults)
          current_params = mandatory + optional
  
          if isinstance(expected_params, tuple):
              # The expected number of parameters can be any value from this
              # tuple, although the user should implement the method
              # to take all of them in consideration.
              emit = mandatory not in expected_params
              expected_params = "between %d or %d" % expected_params
          else:
              # If the number of mandatory parameters doesn't
              # suffice, the expected parameters for this
              # function will be deduced from the optional
              # parameters.
              rest = expected_params - mandatory
              if rest == 0:
                  emit = False
              elif rest < 0:
                  emit = True
              elif rest > 0:
                  emit = not ((optional - rest) >= 0 or node.args.vararg)
  
          if emit:
              verb = "was" if current_params <= 1 else "were"
              self.add_message('unexpected-special-method-signature',
                               args=(node.name, expected_params, current_params, verb),
                               node=node)
  
      @staticmethod
      def _is_iterator(node):
          if node is astroid.YES:
              # Just ignore YES objects.
              return True
          if isinstance(node, Generator):
              # Generators can be itered.
              return True
  
          if isinstance(node, astroid.Instance):
              try:
                  node.local_attr(NEXT_METHOD)
                  return True
              except astroid.NotFoundError:
                  pass
          elif isinstance(node, astroid.ClassDef):
              metaclass = node.metaclass()
              if metaclass and isinstance(metaclass, astroid.ClassDef):
                  try:
                      metaclass.local_attr(NEXT_METHOD)
                      return True
                  except astroid.NotFoundError:
                      pass
          return False
  
      def _check_iter(self, node):
          infered = _safe_infer_call_result(node, node)
          if infered is not None:
              if not self._is_iterator(infered):
                  self.add_message('non-iterator-returned', node=node)
  
      def _check_len(self, node):
          inferred = _safe_infer_call_result(node, node)
          if not inferred:
              return
  
          if not isinstance(inferred, astroid.Const):
              self.add_message('invalid-length-returned', node=node)
              return
  
          value = inferred.value
          if not isinstance(value, six.integer_types) or value < 0:
              self.add_message('invalid-length-returned', node=node)
  
  
  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 node_attr in node.local_attr(method_name):
          if isinstance(node_attr, astroid.Function):
              return node_attr
      raise astroid.NotFoundError(method_name)
  
  def register(linter):
      """required method to auto register this checker """
      linter.register_checker(ClassChecker(linter))
      linter.register_checker(SpecialMethodsChecker(linter))
  