pylint: upgrade to 1.4.0

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
 # 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.
 """basic checker for Python code"""
 
+import collections
+import itertools
 import sys
+import re
+
+import six
+from six.moves import zip  # pylint: disable=redefined-builtin
+
+from logilab.common.ureports import Table
+
 import astroid
-from logilab.common.ureports import Table
+import astroid.bases
 from astroid import are_exclusive, InferenceError
-import astroid.bases
 
-from pylint.interfaces import IAstroidChecker
+from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE, HIGH
 from pylint.utils import EmptyReport
 from pylint.reporters import diff_string
 from pylint.checkers import BaseChecker
 from pylint.checkers.utils import (
     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,
     )
 
 
-import re
-
 # 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}|(__.*__))$')
 # do not require a doc string on system methods
 NO_REQUIRED_DOC_RGX = re.compile('__.*__')
 REVERSED_METHODS = (('__getitem__', '__len__'),
                     ('__reversed__', ))
 
 PY33 = sys.version_info >= (3, 3)
 PY3K = sys.version_info >= (3, 0)
-BAD_FUNCTIONS = ['map', 'filter', 'apply']
+BAD_FUNCTIONS = ['map', 'filter']
 if sys.version_info < (3, 0):
     BAD_FUNCTIONS.append('input')
-    BAD_FUNCTIONS.append('file')
 
 # Name categories that are always consistent with all naming conventions.
 EXEMPT_NAME_CATEGORIES = set(('exempt', 'ignore'))
 
+# A mapping from builtin-qname -> symbol, to be used when generating messages
+# about dangerous default values as arguments
+DEFAULT_ARGUMENT_SYMBOLS = dict(
+    zip(['.'.join([astroid.bases.BUILTINS, x]) for x in ('set', 'dict', 'list')],
+        ['set()', '{}', '[]'])
+)
+
 del re
 
+def _redefines_import(node):
+    """ Detect that the given node (AssName) is inside an
+    exception handler and redefines an import from the tryexcept body.
+    Returns True if the node redefines an import, False otherwise.
+    """
+    current = node
+    while current and not isinstance(current.parent, astroid.ExceptHandler):
+        current = current.parent
+    if not current or not is_import_error(current.parent):
+        return False
+    try_block = current.parent.parent
+    for import_node in try_block.nodes_of_class((astroid.From, astroid.Import)):
+        for name, alias in import_node.names:
+            if alias:
+                if alias == node.name:
+                    return True
+            elif name == node.name:
+                return True
+    return False
+
 def in_loop(node):
     """return True if the node is inside a kind of for loop"""
     parent = node.parent
     while parent is not None:
         if isinstance(parent, (astroid.For, astroid.ListComp, astroid.SetComp,
                                astroid.DictComp, astroid.GenExpr)):
             return True
         parent = parent.parent
     return False
 
@@ skipping 10 matching lines @@
     return False
 
 def _loop_exits_early(loop):
     """Returns true if a loop has a break statement in its body."""
     loop_nodes = (astroid.For, astroid.While)
     # Loop over body explicitly to avoid matching break statements
     # in orelse.
     for child in loop.body:
         if isinstance(child, loop_nodes):
             # break statement may be in orelse of child loop.
+            # pylint: disable=superfluous-parens
             for orelse in (child.orelse or ()):
                 for _ in orelse.nodes_of_class(astroid.Break, skip_klass=loop_nodes):
                     return True
             continue
         for _ in child.nodes_of_class(astroid.Break, skip_klass=loop_nodes):
             return True
     return False
 
+def _is_multi_naming_match(match, node_type, confidence):
+    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.
 
@@ skipping 22 matching lines @@
             return 'attr'
     return 'method'
 
 def decorated_with_abc(func):
     """ Determine if the `func` node is decorated
     with `abc` decorators (abstractmethod et co.)
     """
     if func.decorators:
         for node in func.decorators.nodes:
             try:
-                infered = node.infer().next()
+                infered = next(node.infer())
             except InferenceError:
                 continue
             if infered and infered.qname() in ABC_METHODS:
                 return True
 
 def has_abstract_methods(node):
-    """ Determine if the given `node` has
+    """
+    Determine if the given `node` has
     abstract methods, defined with `abc` module.
     """
     return any(decorated_with_abc(meth)
-               for meth in node.mymethods())
+               for meth in node.methods())
 
 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 82 matching lines @@
                   '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',
                   'abstract-class-instantiated',
                   'Used when an abstract class with `abc.ABCMeta` as metaclass '
-                  'has abstract methods and is instantiated.',
-                  {'minversion': (3, 0)}),
+                  '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.'),
         }
 
     @check_messages('function-redefined')
     def visit_class(self, node):
         self._check_redefinition('class', node)
@@ skipping 69 matching lines @@
                 isinstance(node.operand, astroid.UnaryOp) and
                 (node.operand.op == node.op)):
             self.add_message('nonexistent-operator', node=node, args=node.op*2)
 
     @check_messages('abstract-class-instantiated')
     def visit_callfunc(self, node):
         """ Check instantiating abstract class with
         abc.ABCMeta as metaclass.
         """
         try:
-            infered = node.func.infer().next()
+            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)
         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
-                        has_abstract_methods(infered)):
+                if ancestor.qname() == 'abc.ABC' and abstract_methods:
                     self.add_message('abstract-class-instantiated', node=node)
                     break
             return
-        if (metaclass.qname() == 'abc.ABCMeta' and
-                has_abstract_methods(infered)):
+        if metaclass.qname() == 'abc.ABCMeta' and abstract_methods:
             self.add_message('abstract-class-instantiated', 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 59 matching lines @@
                   'Used when the body of a lambda expression is a function call '
                   'on the same argument list as the lambda itself; such lambda '
                   'expressions are in all but a few cases replaceable with the '
                   'function being called in the body of the lambda.'),
         'W0109': ("Duplicate key %r in dictionary",
                   'duplicate-key',
                   'Used when a dictionary expression binds the same key multiple '
                   'times.'),
         'W0122': ('Use of exec',
                   'exec-used',
-                  'Used when you use the "exec" statement (function for Python 3), to discourage its '
-                  'usage. That doesn\'t mean you can not use it !'),
+                  'Used when you use the "exec" statement (function for Python '
+                  '3), to discourage its usage. That doesn\'t '
+                  'mean you can not use it !'),
         'W0123': ('Use of eval',
                   'eval-used',
                   'Used when you use the "eval" function, to discourage its '
                   'usage. Consider using `ast.literal_eval` for safely evaluating '
                   'strings containing Python expressions '
                   'from untrusted sources. '),
         'W0141': ('Used builtin function %r',
                   'bad-builtin',
                   'Used when a black listed builtin function is used (see the '
                   'bad-function option). Usual black listed functions are the ones '
                   'like map, or filter , where Python offers now some cleaner '
                   'alternative like list comprehension.'),
         'W0142': ('Used * or ** magic',
                   'star-args',
                   'Used when a function or method is called using `*args` or '
                   '`**kwargs` to dispatch arguments. This doesn\'t improve '
                   'readability and should be used with care.'),
         'W0150': ("%s statement in finally block may swallow exception",
                   'lost-exception',
                   'Used when a break or a return statement is found inside the '
                   'finally clause of a try...finally block: the exceptions raised '
                   'in the try clause will be silently swallowed instead of being '
                   're-raised.'),
         'W0199': ('Assert called on a 2-uple. Did you mean \'assert x,y\'?',
                   'assert-on-tuple',
                   'A call of assert on a tuple will always evaluate to true if '
                   'the tuple is not empty, and will always evaluate to false if '
                   'it is.'),
-        'W0121': ('Use raise ErrorClass(args) instead of raise ErrorClass, args.',
-                  'old-raise-syntax',
-                  "Used when the alternate raise syntax 'raise foo, bar' is used "
-                  "instead of 'raise foo(bar)'.",
-                  {'maxversion': (3, 0)}),
-
         'C0121': ('Missing required attribute "%s"', # W0103
                   'missing-module-attribute',
                   'Used when an attribute required for modules is missing.'),
 
         'E0109': ('Missing argument to reversed()',
                   'missing-reversed-argument',
                   'Used when reversed() builtin didn\'t receive an argument.'),
         'E0111': ('The first reversed() argument is not a sequence',
                   'bad-reversed-sequence',
                   'Used when the first argument to reversed() builtin '
@@ skipping 21 matching lines @@
         _BasicChecker.__init__(self, linter)
         self.stats = None
         self._tryfinallys = None
 
     def open(self):
         """initialize visit variables and statistics
         """
         self._tryfinallys = []
         self.stats = self.linter.add_stats(module=0, function=0,
                                            method=0, class_=0)
+
     @check_messages('missing-module-attribute')
     def visit_module(self, node):
         """check module name, docstring and required arguments
         """
         self.stats['module'] += 1
         for attr in self.config.required_attributes:
             if attr not in node:
                 self.add_message('missing-module-attribute', node=node, args=attr)
 
-    def visit_class(self, node):
+    def visit_class(self, node): # pylint: disable=unused-argument
         """check module name, docstring and redefinition
         increment branch counter
         """
         self.stats['class'] += 1
 
     @check_messages('pointless-statement', 'pointless-string-statement',
                     'expression-not-assigned')
     def visit_discard(self, node):
         """check for various kind of statements without effect"""
         expr = node.value
         if isinstance(expr, astroid.Const) and isinstance(expr.value,
-                                                          basestring):
+                                                          six.string_types):
             # treat string statement in a separated message
             # Handle PEP-257 attribute docstrings.
             # An attribute docstring is defined as being a string right after
             # an assignment at the module level, class level or __init__ level.
             scope = expr.scope()
             if isinstance(scope, (astroid.Class, astroid.Module, astroid.Function)):
                 if isinstance(scope, astroid.Function) and scope.name != '__init__':
                     pass
                 else:
                     sibling = expr.previous_sibling()
@@ skipping 56 matching lines @@
             if (not call.starargs
                     or not isinstance(call.starargs, astroid.Name)
                     or node.args.vararg != call.starargs.name):
                 return
         elif call.starargs:
             return
         # The "ordinary" arguments must be in a correspondence such that:
         # ordinary_args[i].name == call.args[i].name.
         if len(ordinary_args) != len(call.args):
             return
-        for i in xrange(len(ordinary_args)):
+        for i in range(len(ordinary_args)):
             if not isinstance(call.args[i], astroid.Name):
                 return
             if node.args.args[i].name != call.args[i].name:
                 return
         if (isinstance(node.body.func, astroid.Getattr) and
-            isinstance(node.body.func.expr, astroid.CallFunc)):
+                isinstance(node.body.func.expr, astroid.CallFunc)):
             # Chained call, the intermediate call might
             # 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
         # check for dangerous default values as arguments
         for default in node.args.defaults:
             try:
-                value = default.infer().next()
+                value = next(default.infer())
             except astroid.InferenceError:
                 continue
-            builtins = astroid.bases.BUILTINS
+
             if (isinstance(value, astroid.Instance) and
-                    value.qname() in ['.'.join([builtins, x]) for x in ('set', 'dict', 'list')]):
+                    value.qname() in DEFAULT_ARGUMENT_SYMBOLS):
                 if value is default:
-                    msg = default.as_string()
+                    msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()]
                 elif type(value) is astroid.Instance:
-                    msg = '%s (%s)' % (default.as_string(), value.qname())
+                    if isinstance(default, astroid.CallFunc):
+                        # this argument is direct call to list() or dict() etc
+                        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:
-                    msg = '%s (%s)' % (default.as_string(), value.as_string())
+                    # 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,))
 
     @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)
@@ skipping 12 matching lines @@
         """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
         """
         # 1 - Is it right sibling ?
         self._check_unreachable(node)
         # 2 - Is it inside final body of a try...finally bloc ?
         self._check_not_in_finally(node, 'break', (astroid.For, astroid.While,))
 
-    @check_messages('unreachable', 'old-raise-syntax')
+    @check_messages('unreachable')
     def visit_raise(self, node):
         """check if the node has a right sibling (if so, that's some unreachable
         code)
         """
         self._check_unreachable(node)
-        if sys.version_info >= (3, 0):
-            return
-        if node.exc is not None and node.inst is not None and node.tback is None:
-            self.add_message('old-raise-syntax', node=node)
 
     @check_messages('exec-used')
     def visit_exec(self, node):
         """just print a warning on exec statements"""
         self.add_message('exec-used', node=node)
 
     @check_messages('bad-builtin', 'star-args', 'eval-used',
                     'exec-used', 'missing-reversed-argument',
                     'bad-reversed-sequence')
     def visit_callfunc(self, node):
@@ skipping 42 matching lines @@
             if isinstance(k, astroid.Const):
                 key = k.value
                 if key in keys:
                     self.add_message('duplicate-key', node=node, args=key)
                 keys.add(key)
 
     def visit_tryfinally(self, node):
         """update try...finally flag"""
         self._tryfinallys.append(node)
 
-    def leave_tryfinally(self, node):
+    def leave_tryfinally(self, node): # pylint: disable=unused-argument
         """update try...finally flag"""
         self._tryfinallys.pop()
 
     def _check_unreachable(self, node):
         """check unreachable code"""
         unreach_stmt = node.next_sibling()
         if unreach_stmt is not None:
             self.add_message('unreachable', node=unreach_stmt)
 
     def _check_not_in_finally(self, node, node_name, breaker_classes=()):
@@ skipping 17 matching lines @@
     def _check_reversed(self, node):
         """ check that the argument to `reversed` is a sequence """
         try:
             argument = safe_infer(get_argument_from_call(node, position=0))
         except NoSuchArgumentError:
             self.add_message('missing-reversed-argument', node=node)
         else:
             if argument is astroid.YES:
                 return
             if argument is None:
-                # nothing was infered
-                # try to see if we have iter()
+                # Nothing was infered.
+                # Try to see if we have iter().
                 if isinstance(node.args[0], astroid.CallFunc):
                     try:
-                        func = node.args[0].func.infer().next()
+                        func = next(node.args[0].func.infer())
                     except InferenceError:
                         return
                     if (getattr(func, 'name', None) == 'iter' and
                             is_builtin_object(func)):
                         self.add_message('bad-reversed-sequence', node=node)
                 return
 
             if isinstance(argument, astroid.Instance):
                 if (argument._proxied.name == 'dict' and
                         is_builtin_object(argument._proxied)):
                     self.add_message('bad-reversed-sequence', node=node)
                     return
                 elif any(ancestor.name == 'dict' and is_builtin_object(ancestor)
                          for ancestor in argument._proxied.ancestors()):
                     # mappings aren't accepted by reversed()
                     self.add_message('bad-reversed-sequence', node=node)
                     return
 
                 for methods in REVERSED_METHODS:
                     for meth in methods:
                         try:
                             argument.getattr(meth)
                         except astroid.NotFoundError:
                             break
                     else:
                         break
                 else:
-                    # check if it is a .deque. It doesn't seem that
+                    # Check if it is a .deque. It doesn't seem that
                     # we can retrieve special methods
-                    # from C implemented constructs
+                    # from C implemented constructs.
                     if argument._proxied.qname().endswith(".deque"):
                         return
                     self.add_message('bad-reversed-sequence', node=node)
             elif not isinstance(argument, (astroid.List, astroid.Tuple)):
                 # everything else is not a proper sequence for reversed()
                 self.add_message('bad-reversed-sequence', node=node)
 
 _NAME_TYPES = {
     'module': (MOD_NAME_RGX, 'module'),
     'const': (CONST_NAME_RGX, 'constant'),
     'class': (CLASS_NAME_RGX, 'class'),
     'function': (DEFAULT_NAME_RGX, 'function'),
     'method': (DEFAULT_NAME_RGX, 'method'),
     'attr': (DEFAULT_NAME_RGX, 'attribute'),
     'argument': (DEFAULT_NAME_RGX, 'argument'),
     'variable': (DEFAULT_NAME_RGX, 'variable'),
     'class_attribute': (CLASS_ATTRIBUTE_RGX, 'class attribute'),
     'inlinevar': (COMP_VAR_RGX, 'inline iteration'),
 }
 
 def _create_naming_options():
     name_options = []
-    for name_type, (rgx, human_readable_name) in _NAME_TYPES.iteritems():
+    for name_type, (rgx, human_readable_name) in six.iteritems(_NAME_TYPES):
         name_type = name_type.replace('_', '-')
         name_options.append((
             '%s-rgx' % (name_type,),
             {'default': rgx, 'type': 'regexp', 'metavar': '<regexp>',
              'help': 'Regular expression matching correct %s names' % (human_readable_name,)}))
         name_options.append((
             '%s-name-hint' % (name_type,),
             {'default': rgx.pattern, 'type': 'string', 'metavar': '<string>',
              'help': 'Naming hint for %s names' % (human_readable_name,)}))
     return tuple(name_options)
@@ skipping 33 matching lines @@
                 {'default': False, 'type' : 'yn', 'metavar' : '<y_or_n>',
                  'help': 'Include a hint for the correct naming format with invalid-name'}
                ),
               ) + _create_naming_options()
 
 
     def __init__(self, linter):
         _BasicChecker.__init__(self, linter)
         self._name_category = {}
         self._name_group = {}
+        self._bad_names = {}
 
     def open(self):
         self.stats = self.linter.add_stats(badname_module=0,
                                            badname_class=0, badname_function=0,
                                            badname_method=0, badname_attr=0,
                                            badname_const=0,
                                            badname_variable=0,
                                            badname_inlinevar=0,
                                            badname_argument=0,
                                            badname_class_attribute=0)
         for group in self.config.name_group:
             for name_type in group.split(':'):
                 self._name_group[name_type] = 'group_%s' % (group,)
 
     @check_messages('blacklisted-name', 'invalid-name')
     def visit_module(self, node):
         self._check_name('module', node.name.split('.')[-1], node)
+        self._bad_names = {}
+
+    def leave_module(self, node): # pylint: disable=unused-argument
+        for all_groups in six.itervalues(self._bad_names):
+            if len(all_groups) < 2:
+                continue
+            groups = collections.defaultdict(list)
+            min_warnings = sys.maxsize
+            for group in six.itervalues(all_groups):
+                groups[len(group)].append(group)
+                min_warnings = min(len(group), min_warnings)
+            if len(groups[min_warnings]) > 1:
+                by_line = sorted(groups[min_warnings],
+                                 key=lambda group: min(warning[0].lineno for warning in group))
+                warnings = itertools.chain(*by_line[1:])
+            else:
+                warnings = groups[min_warnings][0]
+            for args in warnings:
+                self._raise_name_warning(*args)
 
     @check_messages('blacklisted-name', 'invalid-name')
     def visit_class(self, node):
         self._check_name('class', node.name, node)
-        for attr, anodes in node.instance_attrs.iteritems():
+        for attr, anodes in six.iteritems(node.instance_attrs):
             if not list(node.instance_attr_ancestors(attr)):
                 self._check_name('attr', attr, anodes[0])
 
     @check_messages('blacklisted-name', 'invalid-name')
     def visit_function(self, node):
         # Do not emit any warnings if the method is just an implementation
         # of a base class method.
-        if node.is_method() and overrides_a_method(node.parent.frame(), node.name):
-            return
+        confidence = HIGH
+        if node.is_method():
+            if overrides_a_method(node.parent.frame(), node.name):
+                return
+            confidence = (INFERENCE if has_known_bases(node.parent.frame())
+                          else INFERENCE_FAILURE)
+
         self._check_name(_determine_function_name_type(node),
-                         node.name, node)
+                         node.name, node, confidence)
         # Check argument names
         args = node.args.args
         if args is not None:
             self._recursive_check_names(args, node)
 
     @check_messages('blacklisted-name', 'invalid-name')
     def visit_global(self, node):
         for name in node.names:
             self._check_name('const', name, node)
 
     @check_messages('blacklisted-name', 'invalid-name')
     def visit_assname(self, node):
         """check module level assigned names"""
         frame = node.frame()
         ass_type = node.ass_type()
         if isinstance(ass_type, astroid.Comprehension):
             self._check_name('inlinevar', node.name, node)
         elif isinstance(frame, astroid.Module):
             if isinstance(ass_type, astroid.Assign) and not in_loop(ass_type):
                 if isinstance(safe_infer(ass_type.value), astroid.Class):
                     self._check_name('class', node.name, node)
                 else:
-                    self._check_name('const', node.name, node)
+                    if not _redefines_import(node):
+                        # Don't emit if the name redefines an import
+                        # in an ImportError except handler.
+                        self._check_name('const', node.name, node)
             elif isinstance(ass_type, astroid.ExceptHandler):
                 self._check_name('variable', node.name, node)
         elif isinstance(frame, astroid.Function):
             # global introduced variable aren't in the function locals
             if node.name in frame and node.name not in frame.argnames():
-                self._check_name('variable', node.name, node)
+                if not _redefines_import(node):
+                    self._check_name('variable', node.name, node)
         elif isinstance(frame, astroid.Class):
             if not list(frame.local_attr_ancestors(node.name)):
                 self._check_name('class_attribute', node.name, node)
 
     def _recursive_check_names(self, args, node):
         """check names in a possibly recursive list <arg>"""
         for arg in args:
             if isinstance(arg, astroid.AssName):
                 self._check_name('argument', arg.name, node)
             else:
                 self._recursive_check_names(arg.elts, node)
 
     def _find_name_group(self, node_type):
         return self._name_group.get(node_type, node_type)
 
-    def _is_multi_naming_match(self, match):
-        return (match is not None and
-                match.lastgroup is not None and
-                match.lastgroup not in EXEMPT_NAME_CATEGORIES)
+    def _raise_name_warning(self, node, node_type, name, confidence):
+        type_label = _NAME_TYPES[node_type][1]
+        hint = ''
+        if self.config.include_naming_hint:
+            hint = ' (hint: %s)' % (getattr(self.config, node_type + '_name_hint'))
+        self.add_message('invalid-name', node=node, args=(type_label, name, hint),
+                         confidence=confidence)
+        self.stats['badname_' + node_type] += 1
 
-    def _check_name(self, node_type, name, node):
+    def _check_name(self, node_type, name, node, confidence=HIGH):
         """check for a name using the type's regexp"""
         if is_inside_except(node):
             clobbering, _ = clobber_in_except(node)
             if clobbering:
                 return
         if name in self.config.good_names:
             return
         if name in self.config.bad_names:
             self.stats['badname_' + node_type] += 1
             self.add_message('blacklisted-name', node=node, args=name)
             return
         regexp = getattr(self.config, node_type + '_rgx')
         match = regexp.match(name)
 
-        if self._is_multi_naming_match(match):
+        if _is_multi_naming_match(match, node_type, confidence):
             name_group = self._find_name_group(node_type)
-            if name_group not in self._name_category:
-                self._name_category[name_group] = match.lastgroup
-            elif self._name_category[name_group] != match.lastgroup:
-                match = None
+            bad_name_group = self._bad_names.setdefault(name_group, {})
+            warnings = bad_name_group.setdefault(match.lastgroup, [])
+            warnings.append((node, node_type, name, confidence))
 
         if match is None:
-            type_label = _NAME_TYPES[node_type][1]
-            hint = ''
-            if self.config.include_naming_hint:
-                hint = ' (hint: %s)' % (getattr(self.config, node_type + '_name_hint'))
-            self.add_message('invalid-name', node=node, args=(type_label, name, hint))
-            self.stats['badname_' + node_type] += 1
+            self._raise_name_warning(node, node_type, name, confidence)
 
 
 class DocStringChecker(_BasicChecker):
     msgs = {
         'C0111': ('Missing %s docstring', # W0131
                   'missing-docstring',
                   'Used when a module, function, class or method has no docstring.'
                   'Some special methods like __init__ doesn\'t necessary require a '
                   'docstring.'),
         'C0112': ('Empty %s docstring', # W0132
@@ skipping 23 matching lines @@
                                            undocumented_method=0,
                                            undocumented_class=0)
     @check_messages('missing-docstring', 'empty-docstring')
     def visit_module(self, node):
         self._check_docstring('module', node)
 
     @check_messages('missing-docstring', 'empty-docstring')
     def visit_class(self, node):
         if self.config.no_docstring_rgx.match(node.name) is None:
             self._check_docstring('class', node)
+
     @check_messages('missing-docstring', 'empty-docstring')
     def visit_function(self, node):
         if self.config.no_docstring_rgx.match(node.name) is None:
             ftype = node.is_method() and 'method' or 'function'
             if isinstance(node.parent.frame(), astroid.Class):
                 overridden = False
+                confidence = (INFERENCE if has_known_bases(node.parent.frame())
+                              else INFERENCE_FAILURE)
                 # check if node is from a method overridden by its ancestor
                 for ancestor in node.parent.frame().ancestors():
                     if node.name in ancestor and \
                        isinstance(ancestor[node.name], astroid.Function):
                         overridden = True
                         break
                 self._check_docstring(ftype, node,
-                                      report_missing=not overridden)
+                                      report_missing=not overridden,
+                                      confidence=confidence)
             else:
                 self._check_docstring(ftype, node)
 
-    def _check_docstring(self, node_type, node, report_missing=True):
+    def _check_docstring(self, node_type, node, report_missing=True,
+                         confidence=HIGH):
         """check the node has a non empty docstring"""
         docstring = node.doc
         if docstring is None:
             if not report_missing:
                 return
             if node.body:
                 lines = node.body[-1].lineno - node.body[0].lineno + 1
             else:
                 lines = 0
             max_lines = self.config.docstring_min_length
 
             if node_type != 'module' and max_lines > -1 and lines < max_lines:
                 return
             self.stats['undocumented_'+node_type] += 1
             if (node.body and isinstance(node.body[0], astroid.Discard) and
-                isinstance(node.body[0].value, astroid.CallFunc)):
+                    isinstance(node.body[0].value, astroid.CallFunc)):
                 # Most likely a string with a format call. Let's see.
                 func = safe_infer(node.body[0].value.func)
                 if (isinstance(func, astroid.BoundMethod)
-                    and isinstance(func.bound, astroid.Instance)):
+                        and isinstance(func.bound, astroid.Instance)):
                     # Strings in Python 3, others in Python 2.
                     if PY3K and func.bound.name == 'str':
                         return
                     elif func.bound.name in ('str', 'unicode', 'bytes'):
                         return
-            self.add_message('missing-docstring', node=node, args=(node_type,))
+            self.add_message('missing-docstring', node=node, args=(node_type,),
+                             confidence=confidence)
         elif not docstring.strip():
             self.stats['undocumented_'+node_type] += 1
-            self.add_message('empty-docstring', node=node, args=(node_type,))
+            self.add_message('empty-docstring', node=node, args=(node_type,),
+                             confidence=confidence)
 
 
 class PassChecker(_BasicChecker):
     """check if the pass statement is really necessary"""
     msgs = {'W0107': ('Unnecessary pass statement',
                       'unnecessary-pass',
                       'Used when a "pass" statement that can be avoided is '
                       'encountered.'),
            }
     @check_messages('unnecessary-pass')
@@ skipping 33 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))