pylint: upgrade to 1.4.1

third_party/pylint/checkers/base.py

 # Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
 # http://www.logilab.fr/ -- mailto:contact@logilab.fr
 # Copyright (c) 2009-2010 Arista Networks, Inc.
 #
 # 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
@@ skipping 27 matching lines @@
     check_messages,
     clobber_in_except,
     is_builtin_object,
     is_inside_except,
     overrides_a_method,
     safe_infer,
     get_argument_from_call,
     has_known_bases,
     NoSuchArgumentError,
     is_import_error,
+    unimplemented_abstract_methods,
     )
 
 
 # regex for class/function/variable/constant name
 CLASS_NAME_RGX = re.compile('[A-Z_][a-zA-Z0-9]+$')
 MOD_NAME_RGX = re.compile('(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$')
 CONST_NAME_RGX = re.compile('(([A-Z_][A-Z0-9_]*)|(__.*__))$')
 COMP_VAR_RGX = re.compile('[A-Za-z_][A-Za-z0-9_]*$')
 DEFAULT_NAME_RGX = re.compile('[a-z_][a-z0-9_]{2,30}$')
 CLASS_ATTRIBUTE_RGX = re.compile(r'([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$')
@@ skipping 83 matching lines @@
     return (match is not None and
             match.lastgroup is not None and
             match.lastgroup not in EXEMPT_NAME_CATEGORIES
             and (node_type != 'method' or confidence != INFERENCE_FAILURE))
 
 
 if sys.version_info < (3, 0):
     PROPERTY_CLASSES = set(('__builtin__.property', 'abc.abstractproperty'))
 else:
     PROPERTY_CLASSES = set(('builtins.property', 'abc.abstractproperty'))
-ABC_METHODS = set(('abc.abstractproperty', 'abc.abstractmethod',
-                   'abc.abstractclassmethod', 'abc.abstractstaticmethod'))
+
 
 def _determine_function_name_type(node):
     """Determine the name type whose regex the a function's name should match.
 
     :param node: A function node.
     :returns: One of ('function', 'method', 'attr')
     """
     if not node.is_method():
         return 'function'
     if node.decorators:
         decorators = node.decorators.nodes
     else:
         decorators = []
     for decorator in decorators:
         # If the function is a property (decorated with @property
         # or @abc.abstractproperty), the name type is 'attr'.
         if (isinstance(decorator, astroid.Name) or
                 (isinstance(decorator, astroid.Getattr) and
                  decorator.attrname == 'abstractproperty')):
             infered = safe_infer(decorator)
             if infered and infered.qname() in PROPERTY_CLASSES:
                 return 'attr'
         # If the function is decorated using the prop_method.{setter,getter}
         # form, treat it like an attribute as well.
         elif (isinstance(decorator, astroid.Getattr) and
               decorator.attrname in ('setter', 'deleter')):
             return 'attr'
     return 'method'
 
-def decorated_with_abc(func):
-    """ Determine if the `func` node is decorated
-    with `abc` decorators (abstractmethod et co.)
+
+
+def _has_abstract_methods(node):
     """
-    if func.decorators:
-        for node in func.decorators.nodes:
-            try:
-                infered = next(node.infer())
-            except InferenceError:
-                continue
-            if infered and infered.qname() in ABC_METHODS:
-                return True
+    Determine if the given `node` has abstract methods.
 
-def has_abstract_methods(node):
+    The methods should be made abstract by decorating them
+    with `abc` decorators.
     """
-    Determine if the given `node` has
-    abstract methods, defined with `abc` module.
-    """
-    return any(decorated_with_abc(meth)
-               for meth in node.methods())
+    return len(unimplemented_abstract_methods(node)) > 0
+
 
 def report_by_type_stats(sect, stats, old_stats):
     """make a report of
 
     * percentage of different types documented
     * percentage of different types with a bad name
     """
     # percentage of different types documented and/or with a bad name
     nice_stats = {}
     for node_type in ('module', 'class', 'method', 'function'):
@@ skipping 79 matching lines @@
                   '"yield" statements).',
                   {'maxversion': (3, 3)}),
         'E0107': ("Use of the non-existent %s operator",
                   'nonexistent-operator',
                   "Used when you attempt to use the C-style pre-increment or"
                   "pre-decrement operator -- and ++, which doesn't exist in Python."),
         'E0108': ('Duplicate argument name %s in function definition',
                   'duplicate-argument-name',
                   'Duplicate argument names in function definitions are syntax'
                   ' errors.'),
-        'E0110': ('Abstract class with abstract methods instantiated',
+        'E0110': ('Abstract class %r with abstract methods instantiated',
                   'abstract-class-instantiated',
                   'Used when an abstract class with `abc.ABCMeta` as metaclass '
                   'has abstract methods and is instantiated.'),
         'W0120': ('Else clause on loop without a break statement',
                   'useless-else-on-loop',
                   'Loops should only have an else clause if they can exit early '
                   'with a break statement, otherwise the statements under else '
                   'should be on the same scope as the loop itself.'),
         }
 
@@ skipping 79 matching lines @@
         abc.ABCMeta as metaclass.
         """
         try:
             infered = next(node.func.infer())
         except astroid.InferenceError:
             return
         if not isinstance(infered, astroid.Class):
             return
         # __init__ was called
         metaclass = infered.metaclass()
-        abstract_methods = has_abstract_methods(infered)
+        abstract_methods = _has_abstract_methods(infered)
         if metaclass is None:
             # Python 3.4 has `abc.ABC`, which won't be detected
             # by ClassNode.metaclass()
             for ancestor in infered.ancestors():
                 if ancestor.qname() == 'abc.ABC' and abstract_methods:
-                    self.add_message('abstract-class-instantiated', node=node)
+                    self.add_message('abstract-class-instantiated',
+                                     args=(infered.name, ),
+                                     node=node)
                     break
             return
         if metaclass.qname() == 'abc.ABCMeta' and abstract_methods:
-            self.add_message('abstract-class-instantiated', node=node)
+            self.add_message('abstract-class-instantiated',
+                             args=(infered.name, ),
+                             node=node)
 
     def _check_else_on_loop(self, node):
         """Check that any loop with an else clause has a break statement."""
         if node.orelse and not _loop_exits_early(node):
             self.add_message('useless-else-on-loop', node=node,
                              # This is not optimal, but the line previous
                              # to the first statement in the else clause
                              # will usually be the one that contains the else:.
                              line=node.orelse[0].lineno - 1)
 
@@ skipping 247 matching lines @@
             # return something else (but we don't check that, yet).
             return
         self.add_message('unnecessary-lambda', line=node.fromlineno, node=node)
 
     @check_messages('dangerous-default-value')
     def visit_function(self, node):
         """check function name, docstring, arguments, redefinition,
         variable names, max locals
         """
         self.stats[node.is_method() and 'method' or 'function'] += 1
+        self._check_dangerous_default(node)
+
+    def _check_dangerous_default(self, node):
         # check for dangerous default values as arguments
+        is_iterable = lambda n: isinstance(n, (astroid.List,
+                                               astroid.Set,
+                                               astroid.Dict))
         for default in node.args.defaults:
             try:
                 value = next(default.infer())
             except astroid.InferenceError:
                 continue
 
             if (isinstance(value, astroid.Instance) and
                     value.qname() in DEFAULT_ARGUMENT_SYMBOLS):
+
                 if value is default:
                     msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()]
-                elif type(value) is astroid.Instance:
-                    if isinstance(default, astroid.CallFunc):
-                        # this argument is direct call to list() or dict() etc
+                elif type(value) is astroid.Instance or is_iterable(value):
+                    # We are here in the following situation(s):
+                    #   * a dict/set/list/tuple call which wasn't inferred
+                    #     to a syntax node ({}, () etc.). This can happen
+                    #     when the arguments are invalid or unknown to
+                    #     the inference.
+                    #   * a variable from somewhere else, which turns out to be a list
+                    #     or a dict.
+                    if is_iterable(default):
+                        msg = value.pytype()
+                    elif isinstance(default, astroid.CallFunc):
                         msg = '%s() (%s)' % (value.name, value.qname())
                     else:
-                        # this argument is a variable from somewhere else which turns
-                        # out to be a list or dict
                         msg = '%s (%s)' % (default.as_string(), value.qname())
                 else:
                     # this argument is a name
                     msg = '%s (%s)' % (default.as_string(),
                                        DEFAULT_ARGUMENT_SYMBOLS[value.qname()])
-                self.add_message('dangerous-default-value', node=node, args=(msg,))
+                self.add_message('dangerous-default-value',
+                                 node=node,
+                                 args=(msg, ))
 
     @check_messages('unreachable', 'lost-exception')
     def visit_return(self, node):
         """1 - check is the node has a right sibling (if so, that's some
         unreachable code)
         2 - check is the node is inside the finally clause of a try...finally
         block
         """
         self._check_unreachable(node)
         # Is it inside final body of a try...finally bloc ?
@@ skipping 516 matching lines @@
 
 
 def register(linter):
     """required method to auto register this checker"""
     linter.register_checker(BasicErrorChecker(linter))
     linter.register_checker(BasicChecker(linter))
     linter.register_checker(NameChecker(linter))
     linter.register_checker(DocStringChecker(linter))
     linter.register_checker(PassChecker(linter))
     linter.register_checker(LambdaForComprehensionChecker(linter))