libv8 7.8.279.23.0beta1 → 8.4.255.0

data/vendor/depot_tools/third_party/pylint/checkers/typecheck.py

@@ -1,974 +0,0 @@
-# Copyright (c) 2006-2013 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.
-"""try to find more bugs in the code using astroid inference capabilities
-"""
-
-import collections
-import fnmatch
-import re
-import shlex
-import sys
-
-import six
-
-import astroid
-import astroid.context
-import astroid.arguments
-from astroid import exceptions
-from astroid import objects
-from astroid import bases
-
-from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE
-from pylint.checkers import BaseChecker
-from pylint.checkers.utils import (
-    is_super, check_messages, decorated_with_property,
-    decorated_with, node_ignores_exception,
-    is_iterable, is_mapping, supports_membership_test,
-    is_comprehension, is_inside_abstract_class,
-    supports_subscript,
-    safe_infer,
-    has_known_bases)
-from pylint import utils
-
-
-_ZOPE_DEPRECATED = (
-    "This option is deprecated. Use generated-members instead."
-)
-BUILTINS = six.moves.builtins.__name__
-STR_FORMAT = "%s.str.format" % BUILTINS
-
-
-def _unflatten(iterable):
-    for index, elem in enumerate(iterable):
-        if (isinstance(elem, collections.Sequence) and
-                not isinstance(elem, six.string_types)):
-            for elem in _unflatten(elem):
-                yield elem
-        elif elem and not index:
-            # We're interested only in the first element.
-            yield elem
-
-
-def _is_owner_ignored(owner, name, ignored_classes, ignored_modules):
-    """Check if the given owner should be ignored
-
-    This will verify if the owner's module is in *ignored_modules*
-    or the owner's module fully qualified name is in *ignored_modules*
-    or if the *ignored_modules* contains a pattern which catches
-    the fully qualified name of the module.
-
-    Also, similar checks are done for the owner itself, if its name
-    matches any name from the *ignored_classes* or if its qualified
-    name can be found in *ignored_classes*.
-    """
-    ignored_modules = set(ignored_modules)
-    module_name = owner.root().name
-    module_qname = owner.root().qname()
-    if any(module_name in ignored_modules or
-           module_qname in ignored_modules or
-           fnmatch.fnmatch(module_qname, ignore) for ignore in ignored_modules):
-        return True
-
-    ignored_classes = set(ignored_classes)
-    if hasattr(owner, 'qname'):
-        qname = owner.qname()
-    else:
-        qname = ''
-    return any(name == ignore or qname == ignore for ignore in ignored_classes)
-
-
-MSGS = {
-    'E1101': ('%s %r has no %r member',
-              'no-member',
-              'Used when a variable is accessed for an unexistent member.',
-              {'old_names': [('E1103', 'maybe-no-member')]}),
-    'E1102': ('%s is not callable',
-              'not-callable',
-              'Used when an object being called has been inferred to a non \
-              callable object'),
-    'E1111': ('Assigning to function call which doesn\'t return',
-              'assignment-from-no-return',
-              'Used when an assignment is done on a function call but the \
-              inferred function doesn\'t return anything.'),
-    'E1120': ('No value for argument %s in %s call',
-              'no-value-for-parameter',
-              'Used when a function call passes too few arguments.'),
-    'E1121': ('Too many positional arguments for %s call',
-              'too-many-function-args',
-              'Used when a function call passes too many positional \
-              arguments.'),
-    'E1123': ('Unexpected keyword argument %r in %s call',
-              'unexpected-keyword-arg',
-              'Used when a function call passes a keyword argument that \
-              doesn\'t correspond to one of the function\'s parameter names.'),
-    'E1124': ('Argument %r passed by position and keyword in %s call',
-              'redundant-keyword-arg',
-              'Used when a function call would result in assigning multiple \
-              values to a function parameter, one value from a positional \
-              argument and one from a keyword argument.'),
-    'E1125': ('Missing mandatory keyword argument %r in %s call',
-              'missing-kwoa',
-              ('Used when a function call does not pass a mandatory'
-               ' keyword-only argument.'),
-              {'minversion': (3, 0)}),
-    'E1126': ('Sequence index is not an int, slice, or instance with __index__',
-              'invalid-sequence-index',
-              'Used when a sequence type is indexed with an invalid type. '
-              'Valid types are ints, slices, and objects with an __index__ '
-              'method.'),
-    'E1127': ('Slice index is not an int, None, or instance with __index__',
-              'invalid-slice-index',
-              'Used when a slice index is not an integer, None, or an object \
-               with an __index__ method.'),
-    'E1128': ('Assigning to function call which only returns None',
-              'assignment-from-none',
-              'Used when an assignment is done on a function call but the '
-              'inferred function returns nothing but None.',
-              {'old_names': [('W1111', 'assignment-from-none')]}),
-    'E1129': ("Context manager '%s' doesn't implement __enter__ and __exit__.",
-              'not-context-manager',
-              'Used when an instance in a with statement doesn\'t implement '
-              'the context manager protocol(__enter__/__exit__).'),
-    'E1130': ('%s',
-              'invalid-unary-operand-type',
-              'Emitted when an unary operand is used on an object which does not '
-              'support this type of operation'),
-    'E1131': ('%s',
-              'unsupported-binary-operation',
-              'Emitted when a binary arithmetic operation between two '
-              'operands is not supported.'),
-    'E1132': ('Got multiple values for keyword argument %r in function call',
-              'repeated-keyword',
-              'Emitted when a function call got multiple values for a keyword.'),
-    'E1135': ("Value '%s' doesn't support membership test",
-              'unsupported-membership-test',
-              'Emitted when an instance in membership test expression doesn\'t'
-              'implement membership protocol (__contains__/__iter__/__getitem__)'),
-    'E1136': ("Value '%s' is unsubscriptable",
-              'unsubscriptable-object',
-              "Emitted when a subscripted value doesn't support subscription"
-              "(i.e. doesn't define __getitem__ method)"),
-    }
-
-# builtin sequence types in Python 2 and 3.
-SEQUENCE_TYPES = set(['str', 'unicode', 'list', 'tuple', 'bytearray',
-                      'xrange', 'range', 'bytes', 'memoryview'])
-
-
-def _emit_no_member(node, owner, owner_name, ignored_mixins):
-    """Try to see if no-member should be emitted for the given owner.
-
-    The following cases are ignored:
-
-        * the owner is a function and it has decorators.
-        * the owner is an instance and it has __getattr__, __getattribute__ implemented
-        * the module is explicitly ignored from no-member checks
-        * the owner is a class and the name can be found in its metaclass.
-        * The access node is protected by an except handler, which handles
-          AttributeError, Exception or bare except.
-    """
-    if node_ignores_exception(node, AttributeError):
-        return False
-    # skip None anyway
-    if isinstance(owner, astroid.Const) and owner.value is None:
-        return False
-    if is_super(owner) or getattr(owner, 'type', None) == 'metaclass':
-        return False
-    if ignored_mixins and owner_name[-5:].lower() == 'mixin':
-        return False
-    if isinstance(owner, astroid.FunctionDef) and owner.decorators:
-        return False
-    if isinstance(owner, astroid.Instance):
-        if owner.has_dynamic_getattr() or not has_known_bases(owner):
-            return False
-    if isinstance(owner, objects.Super):
-        # Verify if we are dealing with an invalid Super object.
-        # If it is invalid, then there's no point in checking that
-        # it has the required attribute. Also, don't fail if the
-        # MRO is invalid.
-        try:
-            owner.super_mro()
-        except (exceptions.MroError, exceptions.SuperError):
-            return False
-        if not all(map(has_known_bases, owner.type.mro())):
-            return False
-    return True
-
-
-def _determine_callable(callable_obj):
-    # Ordering is important, since BoundMethod is a subclass of UnboundMethod,
-    # and Function inherits Lambda.
-    if isinstance(callable_obj, astroid.BoundMethod):
-        # Bound methods have an extra implicit 'self' argument.
-        return callable_obj, 1, callable_obj.type
-    elif isinstance(callable_obj, astroid.UnboundMethod):
-        return callable_obj, 0, 'unbound method'
-    elif isinstance(callable_obj, astroid.FunctionDef):
-        return callable_obj, 0, callable_obj.type
-    elif isinstance(callable_obj, astroid.Lambda):
-        return callable_obj, 0, 'lambda'
-    elif isinstance(callable_obj, astroid.ClassDef):
-        # Class instantiation, lookup __new__ instead.
-        # If we only find object.__new__, we can safely check __init__
-        # instead. If __new__ belongs to builtins, then we look
-        # again for __init__ in the locals, since we won't have
-        # argument information for the builtin __new__ function.
-        try:
-            # Use the last definition of __new__.
-            new = callable_obj.local_attr('__new__')[-1]
-        except exceptions.NotFoundError:
-            new = None
-
-        from_object = new and new.parent.scope().name == 'object'
-        from_builtins = new and new.root().name in sys.builtin_module_names
-
-        if not new or from_object or from_builtins:
-            try:
-                # Use the last definition of __init__.
-                callable_obj = callable_obj.local_attr('__init__')[-1]
-            except exceptions.NotFoundError:
-                # do nothing, covered by no-init.
-                raise ValueError
-        else:
-            callable_obj = new
-
-        if not isinstance(callable_obj, astroid.FunctionDef):
-            raise ValueError
-        # both have an extra implicit 'cls'/'self' argument.
-        return callable_obj, 1, 'constructor'
-    else:
-        raise ValueError
-
-class TypeChecker(BaseChecker):
-    """try to find bugs in the code using type inference
-    """
-
-    __implements__ = (IAstroidChecker,)
-
-    # configuration section name
-    name = 'typecheck'
-    # messages
-    msgs = MSGS
-    priority = -1
-    # configuration options
-    options = (('ignore-mixin-members',
-                {'default' : True, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'Tells whether missing members accessed in mixin \
-class should be ignored. A mixin class is detected if its name ends with \
-"mixin" (case insensitive).'}
-               ),
-               ('ignored-modules',
-                {'default': (),
-                 'type': 'csv',
-                 'metavar': '<module names>',
-                 'help': 'List of module names for which member attributes '
-                         'should not be checked (useful for modules/projects '
-                         'where namespaces are manipulated during runtime and '
-                         'thus existing member attributes cannot be '
-                         'deduced by static analysis. It supports qualified '
-                         'module names, as well as Unix pattern matching.'}
-               ),
-               ('ignored-classes',
-                {'default' : (),
-                 'type' : 'csv',
-                 'metavar' : '<members names>',
-                 'help' : 'List of classes names for which member attributes '
-                          'should not be checked (useful for classes with '
-                          'attributes dynamically set). This supports '
-                          'can work with qualified names.'}
-               ),
-
-               ('zope', utils.deprecated_option(opt_type='yn',
-                                                help_msg=_ZOPE_DEPRECATED)),
-
-               ('generated-members',
-                {'default' : (),
-                 'type' : 'string',
-                 'metavar' : '<members names>',
-                 'help' : 'List of members which are set dynamically and \
-missed by pylint inference system, and so shouldn\'t trigger E1101 when \
-accessed. Python regular expressions are accepted.'}
-               ),
-              )
-
-    def open(self):
-        # do this in open since config not fully initialized in __init__
-        # generated_members may contain regular expressions
-        # (surrounded by quote `"` and followed by a comma `,`)
-        # REQUEST,aq_parent,"[a-zA-Z]+_set{1,2}"' =>
-        # ('REQUEST', 'aq_parent', '[a-zA-Z]+_set{1,2}')
-        if isinstance(self.config.generated_members, six.string_types):
-            gen = shlex.shlex(self.config.generated_members)
-            gen.whitespace += ','
-            gen.wordchars += '[]-+'
-            self.config.generated_members = tuple(tok.strip('"') for tok in gen)
-
-    def visit_assignattr(self, node):
-        if isinstance(node.assign_type(), astroid.AugAssign):
-            self.visit_attribute(node)
-
-    def visit_delattr(self, node):
-        self.visit_attribute(node)
-
-    @check_messages('no-member')
-    def visit_attribute(self, node):
-        """check that the accessed attribute exists
-
-        to avoid too much false positives for now, we'll consider the code as
-        correct if a single of the inferred nodes has the accessed attribute.
-
-        function/method, super call and metaclasses are ignored
-        """
-        for pattern in self.config.generated_members:
-            # attribute is marked as generated, stop here
-            if re.match(pattern, node.attrname):
-                return
-
-        try:
-            infered = list(node.expr.infer())
-        except exceptions.InferenceError:
-            return
-        # list of (node, nodename) which are missing the attribute
-        missingattr = set()
-        inference_failure = False
-        for owner in infered:
-            # skip yes object
-            if owner is astroid.YES:
-                inference_failure = True
-                continue
-
-            name = getattr(owner, 'name', None)
-            if _is_owner_ignored(owner, name, self.config.ignored_classes,
-                                 self.config.ignored_modules):
-                continue
-
-            try:
-                if not [n for n in owner.getattr(node.attrname)
-                        if not isinstance(n.statement(), astroid.AugAssign)]:
-                    missingattr.add((owner, name))
-                    continue
-            except AttributeError:
-                # XXX method / function
-                continue
-            except exceptions.NotFoundError:
-                # This can't be moved before the actual .getattr call,
-                # because there can be more values inferred and we are
-                # stopping after the first one which has the attribute in question.
-                # The problem is that if the first one has the attribute,
-                # but we continue to the next values which doesn't have the
-                # attribute, then we'll have a false positive.
-                # So call this only after the call has been made.
-                if not _emit_no_member(node, owner, name,
-                                       self.config.ignore_mixin_members):
-                    continue
-                missingattr.add((owner, name))
-                continue
-            # stop on the first found
-            break
-        else:
-            # we have not found any node with the attributes, display the
-            # message for infered nodes
-            done = set()
-            for owner, name in missingattr:
-                if isinstance(owner, astroid.Instance):
-                    actual = owner._proxied
-                else:
-                    actual = owner
-                if actual in done:
-                    continue
-                done.add(actual)
-                confidence = INFERENCE if not inference_failure else INFERENCE_FAILURE
-                self.add_message('no-member', node=node,
-                                 args=(owner.display_type(), name,
-                                       node.attrname),
-                                 confidence=confidence)
-
-    @check_messages('assignment-from-no-return', 'assignment-from-none')
-    def visit_assign(self, node):
-        """check that if assigning to a function call, the function is
-        possibly returning something valuable
-        """
-        if not isinstance(node.value, astroid.Call):
-            return
-        function_node = safe_infer(node.value.func)
-        # skip class, generator and incomplete function definition
-        if not (isinstance(function_node, astroid.FunctionDef) and
-                function_node.root().fully_defined()):
-            return
-        if function_node.is_generator() \
-               or function_node.is_abstract(pass_is_abstract=False):
-            return
-        returns = list(function_node.nodes_of_class(astroid.Return,
-                                                    skip_klass=astroid.FunctionDef))
-        if len(returns) == 0:
-            self.add_message('assignment-from-no-return', node=node)
-        else:
-            for rnode in returns:
-                if not (isinstance(rnode.value, astroid.Const)
-                        and rnode.value.value is None
-                        or rnode.value is None):
-                    break
-            else:
-                self.add_message('assignment-from-none', node=node)
-
-    def _check_uninferable_callfunc(self, node):
-        """
-        Check that the given uninferable CallFunc node does not
-        call an actual function.
-        """
-        if not isinstance(node.func, astroid.Attribute):
-            return
-
-        # Look for properties. First, obtain
-        # the lhs of the Getattr node and search the attribute
-        # there. If that attribute is a property or a subclass of properties,
-        # then most likely it's not callable.
-
-        # TODO: since astroid doesn't understand descriptors very well
-        # we will not handle them here, right now.
-
-        expr = node.func.expr
-        klass = safe_infer(expr)
-        if (klass is None or klass is astroid.YES or
-                not isinstance(klass, astroid.Instance)):
-            return
-
-        try:
-            attrs = klass._proxied.getattr(node.func.attrname)
-        except exceptions.NotFoundError:
-            return
-
-        for attr in attrs:
-            if attr is astroid.YES:
-                continue
-            if not isinstance(attr, astroid.FunctionDef):
-                continue
-
-            # Decorated, see if it is decorated with a property.
-            # Also, check the returns and see if they are callable.
-            if decorated_with_property(attr):
-                if all(return_node.callable()
-                       for return_node in attr.infer_call_result(node)):
-                    continue
-                else:
-                    self.add_message('not-callable', node=node,
-                                     args=node.func.as_string())
-                    break
-
-    @staticmethod
-    def _no_context_variadic(node):
-        """Verify if the given call node has variadic nodes without context
-
-        This is a workaround for handling cases of nested call functions
-        which don't have the specific call context at hand.
-        Variadic arguments (variable positional arguments and variable
-        keyword arguments) are inferred, inherently wrong, by astroid
-        as a Tuple, respectively a Dict with empty elements.
-        This can lead pylint to believe that a function call receives
-        too few arguments.
-        """
-        for arg in node.args:
-            if not isinstance(arg, astroid.Starred):
-                continue
-
-            inferred = safe_infer(arg.value)
-            if isinstance(inferred, astroid.Tuple):
-                length = len(inferred.elts)
-            elif isinstance(inferred, astroid.Dict):
-                length = len(inferred.items)
-            else:
-                return False
-            if not length and isinstance(inferred.statement(), astroid.FunctionDef):
-                return True
-        return False
-
-    @check_messages(*(list(MSGS.keys())))
-    def visit_call(self, node):
-        """check that called functions/methods are inferred to callable objects,
-        and that the arguments passed to the function match the parameters in
-        the inferred function's definition
-        """
-        # Build the set of keyword arguments, checking for duplicate keywords,
-        # and count the positional arguments.
-        call_site = astroid.arguments.CallSite.from_call(node)
-        num_positional_args = len(call_site.positional_arguments)
-        keyword_args = list(call_site.keyword_arguments.keys())
-        no_context_variadic = self._no_context_variadic(node)
-
-        called = safe_infer(node.func)
-        # only function, generator and object defining __call__ are allowed
-        if called is not None and not called.callable():
-            self.add_message('not-callable', node=node,
-                             args=node.func.as_string())
-
-        self._check_uninferable_callfunc(node)
-
-        try:
-            called, implicit_args, callable_name = _determine_callable(called)
-        except ValueError:
-            # Any error occurred during determining the function type, most of
-            # those errors are handled by different warnings.
-            return
-
-        num_positional_args += implicit_args
-        if called.args.args is None:
-            # Built-in functions have no argument information.
-            return
-
-        if len(called.argnames()) != len(set(called.argnames())):
-            # Duplicate parameter name (see duplicate-argument).  We can't really
-            # make sense of the function call in this case, so just return.
-            return
-
-        # Warn about duplicated keyword arguments, such as `f=24, **{'f': 24}`
-        for keyword in call_site.duplicated_keywords:
-            self.add_message('repeated-keyword',
-                             node=node, args=(keyword, ))
-
-        if call_site.has_invalid_arguments() or call_site.has_invalid_keywords():
-            # Can't make sense of this.
-            return
-
-        # Analyze the list of formal parameters.
-        num_mandatory_parameters = len(called.args.args) - len(called.args.defaults)
-        parameters = []
-        parameter_name_to_index = {}
-        for i, arg in enumerate(called.args.args):
-            if isinstance(arg, astroid.Tuple):
-                name = None
-                # Don't store any parameter names within the tuple, since those
-                # are not assignable from keyword arguments.
-            else:
-                assert isinstance(arg, astroid.AssignName)
-                # This occurs with:
-                #    def f( (a), (b) ): pass
-                name = arg.name
-                parameter_name_to_index[name] = i
-            if i >= num_mandatory_parameters:
-                defval = called.args.defaults[i - num_mandatory_parameters]
-            else:
-                defval = None
-            parameters.append([(name, defval), False])
-
-        kwparams = {}
-        for i, arg in enumerate(called.args.kwonlyargs):
-            if isinstance(arg, astroid.Keyword):
-                name = arg.arg
-            else:
-                assert isinstance(arg, astroid.AssignName)
-                name = arg.name
-            kwparams[name] = [called.args.kw_defaults[i], False]
-
-        # Match the supplied arguments against the function parameters.
-
-        # 1. Match the positional arguments.
-        for i in range(num_positional_args):
-            if i < len(parameters):
-                parameters[i][1] = True
-            elif called.args.vararg is not None:
-                # The remaining positional arguments get assigned to the *args
-                # parameter.
-                break
-            else:
-                # Too many positional arguments.
-                self.add_message('too-many-function-args',
-                                 node=node, args=(callable_name,))
-                break
-
-        # 2. Match the keyword arguments.
-        for keyword in keyword_args:
-            if keyword in parameter_name_to_index:
-                i = parameter_name_to_index[keyword]
-                if parameters[i][1]:
-                    # Duplicate definition of function parameter.
-
-                    # Might be too hardcoded, but this can actually
-                    # happen when using str.format and `self` is passed
-                    # by keyword argument, as in `.format(self=self)`.
-                    # It's perfectly valid to so, so we're just skipping
-                    # it if that's the case.
-                    if not (keyword == 'self' and called.qname() == STR_FORMAT):
-                        self.add_message('redundant-keyword-arg',
-                                         node=node, args=(keyword, callable_name))
-                else:
-                    parameters[i][1] = True
-            elif keyword in kwparams:
-                if kwparams[keyword][1]:  # XXX is that even possible?
-                    # Duplicate definition of function parameter.
-                    self.add_message('redundant-keyword-arg', node=node,
-                                     args=(keyword, callable_name))
-                else:
-                    kwparams[keyword][1] = True
-            elif called.args.kwarg is not None:
-                # The keyword argument gets assigned to the **kwargs parameter.
-                pass
-            else:
-                # Unexpected keyword argument.
-                self.add_message('unexpected-keyword-arg', node=node,
-                                 args=(keyword, callable_name))
-
-        # 3. Match the **kwargs, if any.
-        if node.kwargs:
-            for i, [(name, defval), assigned] in enumerate(parameters):
-                # Assume that *kwargs provides values for all remaining
-                # unassigned named parameters.
-                if name is not None:
-                    parameters[i][1] = True
-                else:
-                    # **kwargs can't assign to tuples.
-                    pass
-
-        # Check that any parameters without a default have been assigned
-        # values.
-        for [(name, defval), assigned] in parameters:
-            if (defval is None) and not assigned:
-                if name is None:
-                    display_name = '<tuple>'
-                else:
-                    display_name = repr(name)
-                # TODO(cpopa): this should be removed after PyCQA/astroid/issues/177
-                if not no_context_variadic:
-                    self.add_message('no-value-for-parameter', node=node,
-                                     args=(display_name, callable_name))
-
-        for name in kwparams:
-            defval, assigned = kwparams[name]
-            if defval is None and not assigned:
-                self.add_message('missing-kwoa', node=node,
-                                 args=(name, callable_name))
-
-    @check_messages('invalid-sequence-index')
-    def visit_extslice(self, node):
-        # Check extended slice objects as if they were used as a sequence
-        # index to check if the object being sliced can support them
-        return self.visit_index(node)
-
-    @check_messages('invalid-sequence-index')
-    def visit_index(self, node):
-        if not node.parent or not hasattr(node.parent, "value"):
-            return
-        # Look for index operations where the parent is a sequence type.
-        # If the types can be determined, only allow indices to be int,
-        # slice or instances with __index__.
-        parent_type = safe_infer(node.parent.value)
-        if not isinstance(parent_type, (astroid.ClassDef, astroid.Instance)):
-            return
-
-        # Determine what method on the parent this index will use
-        # The parent of this node will be a Subscript, and the parent of that
-        # node determines if the Subscript is a get, set, or delete operation.
-        operation = node.parent.parent
-        if isinstance(operation, astroid.Assign):
-            methodname = '__setitem__'
-        elif isinstance(operation, astroid.Delete):
-            methodname = '__delitem__'
-        else:
-            methodname = '__getitem__'
-
-        # Check if this instance's __getitem__, __setitem__, or __delitem__, as
-        # appropriate to the statement, is implemented in a builtin sequence
-        # type. This way we catch subclasses of sequence types but skip classes
-        # that override __getitem__ and which may allow non-integer indices.
-        try:
-            methods = parent_type.getattr(methodname)
-            if methods is astroid.YES:
-                return
-            itemmethod = methods[0]
-        except (exceptions.NotFoundError, IndexError):
-            return
-        if not isinstance(itemmethod, astroid.FunctionDef):
-            return
-        if itemmethod.root().name != BUILTINS:
-            return
-        if not itemmethod.parent:
-            return
-        if itemmethod.parent.name not in SEQUENCE_TYPES:
-            return
-
-        # For ExtSlice objects coming from visit_extslice, no further
-        # inference is necessary, since if we got this far the ExtSlice
-        # is an error.
-        if isinstance(node, astroid.ExtSlice):
-            index_type = node
-        else:
-            index_type = safe_infer(node)
-        if index_type is None or index_type is astroid.YES:
-            return
-        # Constants must be of type int
-        if isinstance(index_type, astroid.Const):
-            if isinstance(index_type.value, int):
-                return
-        # Instance values must be int, slice, or have an __index__ method
-        elif isinstance(index_type, astroid.Instance):
-            if index_type.pytype() in (BUILTINS + '.int', BUILTINS + '.slice'):
-                return
-            try:
-                index_type.getattr('__index__')
-                return
-            except exceptions.NotFoundError:
-                pass
-        elif isinstance(index_type, astroid.Slice):
-            # Delegate to visit_slice. A slice can be present
-            # here after inferring the index node, which could
-            # be a `slice(...)` call for instance.
-            return self.visit_slice(index_type)
-
-        # Anything else is an error
-        self.add_message('invalid-sequence-index', node=node)
-
-    @check_messages('invalid-slice-index')
-    def visit_slice(self, node):
-        # Check the type of each part of the slice
-        for index in (node.lower, node.upper, node.step):
-            if index is None:
-                continue
-
-            index_type = safe_infer(index)
-            if index_type is None or index_type is astroid.YES:
-                continue
-
-            # Constants must of type int or None
-            if isinstance(index_type, astroid.Const):
-                if isinstance(index_type.value, (int, type(None))):
-                    continue
-            # Instance values must be of type int, None or an object
-            # with __index__
-            elif isinstance(index_type, astroid.Instance):
-                if index_type.pytype() in (BUILTINS + '.int',
-                                           BUILTINS + '.NoneType'):
-                    continue
-
-                try:
-                    index_type.getattr('__index__')
-                    return
-                except exceptions.NotFoundError:
-                    pass
-
-            # Anything else is an error
-            self.add_message('invalid-slice-index', node=node)
-
-    @check_messages('not-context-manager')
-    def visit_with(self, node):
-        for ctx_mgr, _ in node.items:
-            context = astroid.context.InferenceContext()
-            infered = safe_infer(ctx_mgr, context=context)
-            if infered is None or infered is astroid.YES:
-                continue
-
-            if isinstance(infered, bases.Generator):
-                # Check if we are dealing with a function decorated
-                # with contextlib.contextmanager.
-                if decorated_with(infered.parent, ['contextlib.contextmanager']):
-                    continue
-                # If the parent of the generator is not the context manager itself,
-                # that means that it could have been returned from another
-                # function which was the real context manager.
-                # The following approach is more of a hack rather than a real
-                # solution: walk all the inferred statements for the
-                # given *ctx_mgr* and if you find one function scope
-                # which is decorated, consider it to be the real
-                # manager and give up, otherwise emit not-context-manager.
-                # See the test file for not_context_manager for a couple
-                # of self explaining tests.
-                for path in six.moves.filter(None, _unflatten(context.path)):
-                    scope = path.scope()
-                    if not isinstance(scope, astroid.FunctionDef):
-                        continue
-                    if decorated_with(scope, ['contextlib.contextmanager']):
-                        break
-                else:
-                    self.add_message('not-context-manager',
-                                     node=node, args=(infered.name, ))
-            else:
-                try:
-                    infered.getattr('__enter__')
-                    infered.getattr('__exit__')
-                except exceptions.NotFoundError:
-                    if isinstance(infered, astroid.Instance):
-                        # If we do not know the bases of this class,
-                        # just skip it.
-                        if not has_known_bases(infered):
-                            continue
-                        # Just ignore mixin classes.
-                        if self.config.ignore_mixin_members:
-                            if infered.name[-5:].lower() == 'mixin':
-                                continue
-
-                    self.add_message('not-context-manager',
-                                     node=node, args=(infered.name, ))
-
-    # Disabled until we'll have a more capable astroid.
-    @check_messages('invalid-unary-operand-type')
-    def _visit_unaryop(self, node):
-        """Detect TypeErrors for unary operands."""
-
-        for error in node.type_errors():
-            # Let the error customize its output.
-            self.add_message('invalid-unary-operand-type',
-                             args=str(error), node=node)
-
-    @check_messages('unsupported-binary-operation')
-    def _visit_binop(self, node):
-        """Detect TypeErrors for binary arithmetic operands."""
-        self._check_binop_errors(node)
-
-    @check_messages('unsupported-binary-operation')
-    def _visit_augassign(self, node):
-        """Detect TypeErrors for augmented binary arithmetic operands."""
-        self._check_binop_errors(node)
-
-    def _check_binop_errors(self, node):
-        for error in node.type_errors():
-            # Let the error customize its output.
-            self.add_message('unsupported-binary-operation',
-                             args=str(error), node=node)
-
-    def _check_membership_test(self, node):
-        if is_inside_abstract_class(node):
-            return
-        if is_comprehension(node):
-            return
-        infered = safe_infer(node)
-        if infered is None or infered is astroid.YES:
-            return
-        if not supports_membership_test(infered):
-            self.add_message('unsupported-membership-test',
-                             args=node.as_string(),
-                             node=node)
-
-    @check_messages('unsupported-membership-test')
-    def visit_compare(self, node):
-        if len(node.ops) != 1:
-            return
-        operator, right = node.ops[0]
-        if operator in ['in', 'not in']:
-            self._check_membership_test(right)
-
-    @check_messages('unsubscriptable-object')
-    def visit_subscript(self, node):
-        if isinstance(node.value, (astroid.ListComp, astroid.DictComp)):
-            return
-        if isinstance(node.value, astroid.SetComp):
-            self.add_message('unsubscriptable-object',
-                             args=node.value.as_string(),
-                             node=node.value)
-            return
-
-        infered = safe_infer(node.value)
-        if infered is None or infered is astroid.YES:
-            return
-
-        if is_inside_abstract_class(node):
-            return
-
-        if not supports_subscript(infered):
-            self.add_message('unsubscriptable-object',
-                             args=node.value.as_string(),
-                             node=node.value)
-
-
-
-class IterableChecker(BaseChecker):
-    """
-    Checks for non-iterables used in an iterable context.
-    Contexts include:
-    - for-statement
-    - starargs in function call
-    - `yield from`-statement
-    - list, dict and set comprehensions
-    - generator expressions
-    Also checks for non-mappings in function call kwargs.
-    """
-
-    __implements__ = (IAstroidChecker,)
-    name = 'iterable_check'
-
-    msgs = {'E1133': ('Non-iterable value %s is used in an iterating context',
-                      'not-an-iterable',
-                      'Used when a non-iterable value is used in place where'
-                      'iterable is expected'),
-            'E1134': ('Non-mapping value %s is used in a mapping context',
-                      'not-a-mapping',
-                      'Used when a non-mapping value is used in place where'
-                      'mapping is expected'),
-           }
-
-    def _check_iterable(self, node):
-        if is_inside_abstract_class(node):
-            return
-        if is_comprehension(node):
-            return
-        infered = safe_infer(node)
-        if infered is None or infered is astroid.YES:
-            return
-        if not is_iterable(infered):
-            self.add_message('not-an-iterable',
-                             args=node.as_string(),
-                             node=node)
-
-    def _check_mapping(self, node):
-        if is_inside_abstract_class(node):
-            return
-        if isinstance(node, astroid.DictComp):
-            return
-        infered = safe_infer(node)
-        if infered is None or infered is astroid.YES:
-            return
-        if not is_mapping(infered):
-            self.add_message('not-a-mapping',
-                             args=node.as_string(),
-                             node=node)
-
-    @check_messages('not-an-iterable')
-    def visit_for(self, node):
-        self._check_iterable(node.iter)
-
-    @check_messages('not-an-iterable')
-    def visit_yieldfrom(self, node):
-        self._check_iterable(node.value)
-
-    @check_messages('not-an-iterable', 'not-a-mapping')
-    def visit_call(self, node):
-        for stararg in node.starargs:
-            self._check_iterable(stararg.value)
-        for kwarg in node.kwargs:
-            self._check_mapping(kwarg.value)
-
-    @check_messages('not-an-iterable')
-    def visit_listcomp(self, node):
-        for gen in node.generators:
-            self._check_iterable(gen.iter)
-
-    @check_messages('not-an-iterable')
-    def visit_dictcomp(self, node):
-        for gen in node.generators:
-            self._check_iterable(gen.iter)
-
-    @check_messages('not-an-iterable')
-    def visit_setcomp(self, node):
-        for gen in node.generators:
-            self._check_iterable(gen.iter)
-
-    @check_messages('not-an-iterable')
-    def visit_generatorexp(self, node):
-        for gen in node.generators:
-            self._check_iterable(gen.iter)
-
-
-def register(linter):
-    """required method to auto register this checker """
-    linter.register_checker(TypeChecker(linter))
-    linter.register_checker(IterableChecker(linter))