libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -15,26 +15,23 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """Checkers for various standard library functions."""
 
-import six
 import sys
 
+import six
+
 import astroid
 from astroid.bases import Instance
-
 from pylint.interfaces import IAstroidChecker
 from pylint.checkers import BaseChecker
 from pylint.checkers import utils
 
 
-TYPECHECK_COMPARISON_OPERATORS = frozenset(('is', 'is not', '==', '!=', 'in', 'not in'))
-LITERAL_NODE_TYPES = (astroid.Const, astroid.Dict, astroid.List, astroid.Set)
-
+OPEN_FILES = {'open', 'file'}
+UNITTEST_CASE = 'unittest.case'
 if sys.version_info >= (3, 0):
     OPEN_MODULE = '_io'
-    TYPE_QNAME = 'builtins.type'
 else:
     OPEN_MODULE = '__builtin__'
-    TYPE_QNAME = '__builtin__.type'
 
 
 def _check_mode_str(mode):
@@ -79,15 +76,6 @@ def _check_mode_str(mode):
     return True
 
 
-def _is_one_arg_pos_call(call):
-    """Is this a call with exactly 1 argument,
-    where that argument is positional?
-    """
-    return (isinstance(call, astroid.CallFunc)
-            and len(call.args) == 1
-            and not isinstance(call.args[0], astroid.Keyword))
-
-
 class StdlibChecker(BaseChecker):
     __implements__ = (IAstroidChecker,)
     name = 'stdlib'
@@ -112,25 +100,98 @@ class StdlibChecker(BaseChecker):
                   'a condition. If a constant is passed as parameter, that '
                   'condition will be always true. In this case a warning '
                   'should be emitted.'),
-        'W1504': ('Using type() instead of isinstance() for a typecheck.',
-                  'unidiomatic-typecheck',
-                  'The idiomatic way to perform an explicit typecheck in '
-                  'Python is to use isinstance(x, Y) rather than '
-                  'type(x) == Y, type(x) is Y. Though there are unusual '
-                  'situations where these give different results.')
+        'W1505': ('Using deprecated method %s()',
+                  'deprecated-method',
+                  'The method is marked as deprecated and will be removed in '
+                  'a future version of Python. Consider looking for an '
+                  'alternative in the documentation.'),
     }
 
-    @utils.check_messages('bad-open-mode', 'redundant-unittest-assert')
-    def visit_callfunc(self, node):
+    deprecated = {
+        0: [
+            'cgi.parse_qs', 'cgi.parse_qsl',
+            'ctypes.c_buffer',
+            'distutils.command.register.register.check_metadata',
+            'distutils.command.sdist.sdist.check_metadata',
+            'tkinter.Misc.tk_menuBar',
+            'tkinter.Menu.tk_bindForTraversal',
+        ],
+        2: {
+            (2, 6): [
+                'commands.getstatus',
+                'os.popen2',
+                'os.popen3',
+                'os.popen4',
+                'macostools.touched',
+            ],
+            (2, 7): [
+                'unittest.case.TestCase.assertEquals',
+                'unittest.case.TestCase.assertNotEquals',
+                'unittest.case.TestCase.assertAlmostEquals',
+                'unittest.case.TestCase.assertNotAlmostEquals',
+                'unittest.case.TestCase.assert_',
+                'xml.etree.ElementTree.Element.getchildren',
+                'xml.etree.ElementTree.Element.getiterator',
+                'xml.etree.ElementTree.XMLParser.getiterator',
+                'xml.etree.ElementTree.XMLParser.doctype',
+            ],
+        },
+        3: {
+            (3, 0): [
+                'inspect.getargspec',
+                'unittest.case.TestCase._deprecate.deprecated_func',
+            ],
+            (3, 1): [
+                'base64.encodestring', 'base64.decodestring',
+                'ntpath.splitunc',
+            ],
+            (3, 2): [
+                'cgi.escape',
+                'configparser.RawConfigParser.readfp',
+                'xml.etree.ElementTree.Element.getchildren',
+                'xml.etree.ElementTree.Element.getiterator',
+                'xml.etree.ElementTree.XMLParser.getiterator',
+                'xml.etree.ElementTree.XMLParser.doctype',
+            ],
+            (3, 3): [
+                'inspect.getmoduleinfo', 'inspect.getmodulename',
+                'logging.warn', 'logging.Logger.warn',
+                'logging.LoggerAdapter.warn',
+                'nntplib._NNTPBase.xpath',
+                'platform.popen',
+            ],
+            (3, 4): [
+                'asyncio.tasks.async',
+                'importlib.find_loader',
+                'plistlib.readPlist', 'plistlib.writePlist',
+                'plistlib.readPlistFromBytes',
+                'plistlib.writePlistToBytes',
+                'xml.etree.ElementTree.iterparse',
+            ],
+            (3, 5): [
+                'fractions.gcd',
+                'inspect.getfullargspec', 'inspect.getargvalues',
+                'inspect.formatargspec', 'inspect.formatargvalues',
+                'inspect.getcallargs',
+                'platform.linux_distribution', 'platform.dist',
+            ],
+        },
+    }
+
+    @utils.check_messages('bad-open-mode', 'redundant-unittest-assert',
+                          'deprecated-method')
+    def visit_call(self, node):
         """Visit a CallFunc node."""
-        if hasattr(node, 'func'):
-            infer = utils.safe_infer(node.func)
-            if infer:
-                if infer.root().name == OPEN_MODULE:
-                    if getattr(node.func, 'name', None) in ('open', 'file'):
+        try:
+            for inferred in node.func.infer():
+                if inferred.root().name == OPEN_MODULE:
+                    if getattr(node.func, 'name', None) in OPEN_FILES:
                         self._check_open_mode(node)
-                if infer.root().name == 'unittest.case':
-                    self._check_redundant_assert(node, infer)
+                if inferred.root().name == UNITTEST_CASE:
+                    self._check_redundant_assert(node, inferred)
+                self._check_deprecated_method(node, inferred)
+        except astroid.InferenceError:
+            return
 
     @utils.check_messages('boolean-datetime')
     def visit_unaryop(self, node):
@@ -150,13 +211,34 @@ class StdlibChecker(BaseChecker):
         for value in node.values:
             self._check_datetime(value)
 
-    @utils.check_messages('unidiomatic-typecheck')
-    def visit_compare(self, node):
-        operator, right = node.ops[0]
-        if operator in TYPECHECK_COMPARISON_OPERATORS:
-            left = node.left
-            if _is_one_arg_pos_call(left):
-                self._check_type_x_is_y(node, left, operator, right)
+    def _check_deprecated_method(self, node, inferred):
+        py_vers = sys.version_info[0]
+
+        if isinstance(node.func, astroid.Attribute):
+            func_name = node.func.attrname
+        elif isinstance(node.func, astroid.Name):
+            func_name = node.func.name
+        else:
+            # Not interested in other nodes.
+            return
+
+        # Reject nodes which aren't of interest to us.
+        acceptable_nodes = (astroid.BoundMethod,
+                            astroid.UnboundMethod,
+                            astroid.FunctionDef)
+        if not isinstance(inferred, acceptable_nodes):
+            return
+
+        qname = inferred.qname()
+        if qname in self.deprecated[0]:
+            self.add_message('deprecated-method', node=node,
+                             args=(func_name, ))
+        else:
+            for since_vers, func_list in self.deprecated[py_vers].items():
+                if since_vers <= sys.version_info and qname in func_list:
+                    self.add_message('deprecated-method', node=node,
+                                     args=(func_name, ))
+                    break
 
     def _check_redundant_assert(self, node, infer):
         if (isinstance(infer, astroid.BoundMethod) and
@@ -192,24 +274,6 @@ class StdlibChecker(BaseChecker):
                 self.add_message('bad-open-mode', node=node,
                                  args=mode_arg.value)
 
-    def _check_type_x_is_y(self, node, left, operator, right):
-        """Check for expressions like type(x) == Y."""
-        left_func = utils.safe_infer(left.func)
-        if not (isinstance(left_func, astroid.Class)
-                and left_func.qname() == TYPE_QNAME):
-            return
-
-        if operator in ('is', 'is not') and _is_one_arg_pos_call(right):
-            right_func = utils.safe_infer(right.func)
-            if (isinstance(right_func, astroid.Class)
-                    and right_func.qname() == TYPE_QNAME):
-                # type(x) == type(a)
-                right_arg = utils.safe_infer(right.args[0])
-                if not isinstance(right_arg, LITERAL_NODE_TYPES):
-                    # not e.g. type(x) == type([])
-                    return
-        self.add_message('unidiomatic-typecheck', node=node)
-
 
 def register(linter):
     """required method to auto register this checker """

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

@@ -23,15 +23,14 @@ import tokenize
 import string
 import numbers
 
-import astroid
+import six
 
+import astroid
 from pylint.interfaces import ITokenChecker, IAstroidChecker, IRawChecker
 from pylint.checkers import BaseChecker, BaseTokenChecker
 from pylint.checkers import utils
 from pylint.checkers.utils import check_messages
 
-import six
-
 
 _PY3K = sys.version_info[:2] >= (3, 0)
 _PY27 = sys.version_info[:2] == (2, 7)
@@ -62,7 +61,7 @@ MSGS = {
     'W1301': ("Unused key %r in format string dictionary",
               "unused-format-string-key",
               "Used when a format string that uses named conversion specifiers \
-              is used with a dictionary that conWtains keys not required by the \
+              is used with a dictionary that contains keys not required by the \
               format string."),
     'E1304': ("Missing key %r in format string dictionary",
               "missing-format-string-key",
@@ -77,7 +76,10 @@ MSGS = {
               "too-few-format-args",
               "Used when a format string that uses unnamed conversion \
               specifiers is given too few arguments"),
-
+    'E1310': ("Suspicious argument in %s.%s call",
+              "bad-str-strip-call",
+              "The argument to a str.{l,r,}strip call contains a"
+              " duplicate character, "),
     'W1302': ("Invalid format string",
               "bad-format-string",
               "Used when a PEP 3101 format string is invalid.",
@@ -114,12 +116,12 @@ MSGS = {
               {'minversion': (2, 7)})
     }
 
-OTHER_NODES = (astroid.Const, astroid.List, astroid.Backquote,
-               astroid.Lambda, astroid.Function,
-               astroid.ListComp, astroid.SetComp, astroid.GenExpr)
+OTHER_NODES = (astroid.Const, astroid.List, astroid.Repr,
+               astroid.Lambda, astroid.FunctionDef,
+               astroid.ListComp, astroid.SetComp, astroid.GeneratorExp)
 
 if _PY3K:
-    import _string
+    import _string # pylint: disable=wrong-import-position, wrong-import-order
 
     def split_format_field_names(format_string):
         return _string.formatter_field_name_split(format_string)
@@ -157,9 +159,18 @@ def collect_string_fields(format_string):
             if nested:
                 for field in collect_string_fields(nested):
                     yield field
-    except ValueError:
-        # probably the format string is invalid
-        # should we check the argument of the ValueError?
+    except ValueError as exc:
+        # Probably the format string is invalid.
+        if exc.args[0].startswith("cannot switch from manual"):
+            # On Jython, parsing a string with both manual
+            # and automatic positions will fail with a ValueError,
+            # while on CPython it will simply return the fields,
+            # the validation being done in the interpreter (?).
+            # We're just returning two mixed fields in order
+            # to trigger the format-combined-specification check.
+            yield ""
+            yield "1"
+            return
         raise utils.IncompleteFormatString(format_string)
 
 def parse_format_method_string(format_string):
@@ -189,19 +200,18 @@ def parse_format_method_string(format_string):
     return keys, num_args, len(manual_pos_arg)
 
 def get_args(callfunc):
-    """ Get the arguments from the given `CallFunc` node.
+    """Get the arguments from the given `CallFunc` node.
+
     Return a tuple, where the first element is the
     number of positional arguments and the second element
     is the keyword arguments in a dict.
     """
-    positional = 0
-    named = {}
-
-    for arg in callfunc.args:
-        if isinstance(arg, astroid.Keyword):
-            named[arg.arg] = utils.safe_infer(arg.value)
-        else:
-            positional += 1
+    if callfunc.keywords:
+        named = {arg.arg: utils.safe_infer(arg.value)
+                 for arg in callfunc.keywords}
+    else:
+        named = {}
+    positional = len(callfunc.args)
     return positional, named
 
 def get_access_path(key, parts):
@@ -312,18 +322,8 @@ class StringFormatChecker(BaseChecker):
                     self.add_message('too-few-format-args', node=node)
 
 
-class StringMethodsChecker(BaseChecker):
-    __implements__ = (IAstroidChecker,)
-    name = 'string'
-    msgs = {
-        'E1310': ("Suspicious argument in %s.%s call",
-                  "bad-str-strip-call",
-                  "The argument to a str.{l,r,}strip call contains a"
-                  " duplicate character, "),
-        }
-
     @check_messages(*(MSGS.keys()))
-    def visit_callfunc(self, node):
+    def visit_call(self, node):
         func = utils.safe_infer(node.func)
         if (isinstance(func, astroid.BoundMethod)
                 and isinstance(func.bound, astroid.Instance)
@@ -352,7 +352,7 @@ class StringMethodsChecker(BaseChecker):
         #
         #    fmt = 'some string {}'.format
         #    fmt('arg')
-        if (isinstance(node.func, astroid.Getattr)
+        if (isinstance(node.func, astroid.Attribute)
                 and not isinstance(node.func.expr, astroid.Const)):
             return
         try:
@@ -361,8 +361,10 @@ class StringMethodsChecker(BaseChecker):
             return
         if not isinstance(strnode, astroid.Const):
             return
+        if not isinstance(strnode.value, six.string_types):
+            return
+
         if node.starargs or node.kwargs:
-            # TODO: Don't complicate the logic, skip these for now.
             return
         try:
             positional, named = get_args(node)
@@ -482,6 +484,8 @@ class StringMethodsChecker(BaseChecker):
                             previous = previous.getitem(specifier)
                         except (IndexError, TypeError):
                             warn_error = True
+                        except astroid.InferenceError:
+                            break
                     else:
                         try:
                             # Lookup __getitem__ in the current node,
@@ -611,5 +615,4 @@ class StringConstantChecker(BaseTokenChecker):
 def register(linter):
     """required method to auto register this checker """
     linter.register_checker(StringFormatChecker(linter))
-    linter.register_checker(StringMethodsChecker(linter))
     linter.register_checker(StringConstantChecker(linter))

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

@@ -16,18 +16,79 @@
 """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
-from astroid import InferenceError, NotFoundError, YES, Instance
-from astroid.bases import BUILTINS
+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 (
-    safe_infer, is_super,
-    check_messages, decorated_with_property)
+    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',
@@ -42,11 +103,6 @@ MSGS = {
               'assignment-from-no-return',
               'Used when an assignment is done on a function call but the \
               inferred function doesn\'t return anything.'),
-    'W1111': ('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.'),
-
     'E1120': ('No value for argument %s in %s call',
               'no-value-for-parameter',
               'Used when a function call passes too few arguments.'),
@@ -77,12 +133,81 @@ MSGS = {
               '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.
@@ -91,31 +216,36 @@ def _determine_callable(callable_obj):
         return callable_obj, 1, callable_obj.type
     elif isinstance(callable_obj, astroid.UnboundMethod):
         return callable_obj, 0, 'unbound method'
-    elif isinstance(callable_obj, astroid.Function):
+    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.Class):
+    elif isinstance(callable_obj, astroid.ClassDef):
         # Class instantiation, lookup __new__ instead.
         # If we only find object.__new__, we can safely check __init__
-        # instead.
+        # 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 astroid.NotFoundError:
+        except exceptions.NotFoundError:
             new = None
 
-        if not new or new.parent.scope().name == 'object':
+        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 astroid.NotFoundError:
+            except exceptions.NotFoundError:
                 # do nothing, covered by no-init.
                 raise ValueError
         else:
             callable_obj = new
 
-        if not isinstance(callable_obj, astroid.Function):
+        if not isinstance(callable_obj, astroid.FunctionDef):
             raise ValueError
         # both have an extra implicit 'cls'/'self' argument.
         return callable_obj, 1, 'constructor'
@@ -144,93 +274,87 @@ class should be ignored. A mixin class is detected if its name ends with \
                 {'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'},
+                 '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' : ('SQLObject',),
+                {'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).'}
+                 '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',
-                {'default' : False, 'type' : 'yn', 'metavar': '<y_or_n>',
-                 'help' : 'When zope mode is activated, add a predefined set \
-of Zope acquired attributes to generated-members.'}
-               ),
+               ('zope', utils.deprecated_option(opt_type='yn',
+                                                help_msg=_ZOPE_DEPRECATED)),
+
                ('generated-members',
-                {'default' : ('REQUEST', 'acl_users', 'aq_parent'),
+                {'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 E0201 when \
+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__
-        self.generated_members = list(self.config.generated_members)
-        if self.config.zope:
-            self.generated_members.extend(('REQUEST', 'acl_users', 'aq_parent'))
+        # 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_assattr(self, node):
-        if isinstance(node.ass_type(), astroid.AugAssign):
-            self.visit_getattr(node)
+    def visit_assignattr(self, node):
+        if isinstance(node.assign_type(), astroid.AugAssign):
+            self.visit_attribute(node)
 
     def visit_delattr(self, node):
-        self.visit_getattr(node)
+        self.visit_attribute(node)
 
     @check_messages('no-member')
-    def visit_getattr(self, node):
+    def visit_attribute(self, node):
         """check that the accessed attribute exists
 
-        to avoid to much false positives for now, we'll consider the code as
+        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
         """
-        # generated_members may containt 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, str):
-            gen = shlex.shlex(self.config.generated_members)
-            gen.whitespace += ','
-            gen.wordchars += '[]-+'
-            self.config.generated_members = tuple(tok.strip('"') for tok in gen)
         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 InferenceError:
+        except exceptions.InferenceError:
             return
         # list of (node, nodename) which are missing the attribute
         missingattr = set()
-        ignoremim = self.config.ignore_mixin_members
         inference_failure = False
         for owner in infered:
             # skip yes object
-            if owner is YES:
+            if owner is astroid.YES:
                 inference_failure = True
                 continue
-            # skip None anyway
-            if isinstance(owner, astroid.Const) and owner.value is None:
-                continue
-            # XXX "super" / metaclass call
-            if is_super(owner) or getattr(owner, 'type', None) == 'metaclass':
-                continue
-            name = getattr(owner, 'name', 'None')
-            if name in self.config.ignored_classes:
-                continue
-            if ignoremim and name[-5:].lower() == 'mixin':
+
+            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)]:
@@ -239,28 +363,17 @@ accessed. Python regular expressions are accepted.'}
             except AttributeError:
                 # XXX method / function
                 continue
-            except NotFoundError:
-                if isinstance(owner, astroid.Function) and owner.decorators:
+            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
-                if isinstance(owner, Instance) and owner.has_dynamic_getattr():
-                    continue
-                # explicit skipping of module member access
-                if owner.root().name in self.config.ignored_modules:
-                    continue
-                if isinstance(owner, astroid.Class):
-                    # Look up in the metaclass only if the owner is itself
-                    # a class.
-                    # TODO: getattr doesn't return by default members
-                    # from the metaclass, because handling various cases
-                    # of methods accessible from the metaclass itself
-                    # and/or subclasses only is too complicated for little to
-                    # no benefit.
-                    metaclass = owner.metaclass()
-                    try:
-                        if metaclass and metaclass.getattr(node.attrname):
-                            continue
-                    except NotFoundError:
-                        pass
                 missingattr.add((owner, name))
                 continue
             # stop on the first found
@@ -270,7 +383,7 @@ accessed. Python regular expressions are accepted.'}
             # message for infered nodes
             done = set()
             for owner, name in missingattr:
-                if isinstance(owner, Instance):
+                if isinstance(owner, astroid.Instance):
                     actual = owner._proxied
                 else:
                     actual = owner
@@ -288,18 +401,18 @@ accessed. Python regular expressions are accepted.'}
         """check that if assigning to a function call, the function is
         possibly returning something valuable
         """
-        if not isinstance(node.value, astroid.CallFunc):
+        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.Function) and
+        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.Function))
+                                                    skip_klass=astroid.FunctionDef))
         if len(returns) == 0:
             self.add_message('assignment-from-no-return', node=node)
         else:
@@ -316,7 +429,7 @@ accessed. Python regular expressions are accepted.'}
         Check that the given uninferable CallFunc node does not
         call an actual function.
         """
-        if not isinstance(node.func, astroid.Getattr):
+        if not isinstance(node.func, astroid.Attribute):
             return
 
         # Look for properties. First, obtain
@@ -335,13 +448,13 @@ accessed. Python regular expressions are accepted.'}
 
         try:
             attrs = klass._proxied.getattr(node.func.attrname)
-        except astroid.NotFoundError:
+        except exceptions.NotFoundError:
             return
 
         for attr in attrs:
             if attr is astroid.YES:
                 continue
-            if not isinstance(attr, astroid.Function):
+            if not isinstance(attr, astroid.FunctionDef):
                 continue
 
             # Decorated, see if it is decorated with a property.
@@ -355,21 +468,45 @@ accessed. Python regular expressions are accepted.'}
                                      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_callfunc(self, node):
+    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.
-        keyword_args = set()
-        num_positional_args = 0
-        for arg in node.args:
-            if isinstance(arg, astroid.Keyword):
-                keyword_args.add(arg.arg)
-            else:
-                num_positional_args += 1
+        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
@@ -385,14 +522,24 @@ accessed. Python regular expressions are accepted.'}
             # 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 E9801).  We can't really make sense
-            # of the function call in this case, so just return.
+            # 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.
@@ -405,13 +552,10 @@ accessed. Python regular expressions are accepted.'}
                 # Don't store any parameter names within the tuple, since those
                 # are not assignable from keyword arguments.
             else:
-                if isinstance(arg, astroid.Keyword):
-                    name = arg.arg
-                else:
-                    assert isinstance(arg, astroid.AssName)
-                    # This occurs with:
-                    #    def f( (a), (b) ): pass
-                    name = arg.name
+                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]
@@ -424,7 +568,7 @@ accessed. Python regular expressions are accepted.'}
             if isinstance(arg, astroid.Keyword):
                 name = arg.arg
             else:
-                assert isinstance(arg, astroid.AssName)
+                assert isinstance(arg, astroid.AssignName)
                 name = arg.name
             kwparams[name] = [called.args.kw_defaults[i], False]
 
@@ -450,8 +594,15 @@ accessed. Python regular expressions are accepted.'}
                 i = parameter_name_to_index[keyword]
                 if parameters[i][1]:
                     # Duplicate definition of function parameter.
-                    self.add_message('redundant-keyword-arg',
-                                     node=node, args=(keyword, callable_name))
+
+                    # 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:
@@ -469,24 +620,8 @@ accessed. Python regular expressions are accepted.'}
                 self.add_message('unexpected-keyword-arg', node=node,
                                  args=(keyword, callable_name))
 
-        # 3. Match the *args, if any.  Note that Python actually processes
-        #    *args _before_ any keyword arguments, but we wait until after
-        #    looking at the keyword arguments so as to make a more conservative
-        #    guess at how many values are in the *args sequence.
-        if node.starargs is not None:
-            for i in range(num_positional_args, len(parameters)):
-                [(name, defval), assigned] = parameters[i]
-                # Assume that *args provides just enough values for all
-                # non-default parameters after the last parameter assigned by
-                # the positional arguments but before the first parameter
-                # assigned by the keyword arguments.  This is the best we can
-                # get without generating any false positives.
-                if (defval is not None) or assigned:
-                    break
-                parameters[i][1] = True
-
-        # 4. Match the **kwargs, if any.
-        if node.kwargs is not None:
+        # 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.
@@ -504,8 +639,10 @@ accessed. Python regular expressions are accepted.'}
                     display_name = '<tuple>'
                 else:
                     display_name = repr(name)
-                self.add_message('no-value-for-parameter', node=node,
-                                 args=(display_name, callable_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]
@@ -523,13 +660,11 @@ accessed. Python regular expressions are accepted.'}
     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.Class, astroid.Instance)):
+        if not isinstance(parent_type, (astroid.ClassDef, astroid.Instance)):
             return
 
         # Determine what method on the parent this index will use
@@ -552,10 +687,9 @@ accessed. Python regular expressions are accepted.'}
             if methods is astroid.YES:
                 return
             itemmethod = methods[0]
-        except (astroid.NotFoundError, IndexError):
+        except (exceptions.NotFoundError, IndexError):
             return
-
-        if not isinstance(itemmethod, astroid.Function):
+        if not isinstance(itemmethod, astroid.FunctionDef):
             return
         if itemmethod.root().name != BUILTINS:
             return
@@ -573,7 +707,6 @@ accessed. Python regular expressions are accepted.'}
             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):
@@ -585,8 +718,13 @@ accessed. Python regular expressions are accepted.'}
             try:
                 index_type.getattr('__index__')
                 return
-            except astroid.NotFoundError:
+            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)
@@ -616,12 +754,221 @@ accessed. Python regular expressions are accepted.'}
                 try:
                     index_type.getattr('__index__')
                     return
-                except astroid.NotFoundError:
+                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))