[content/test/gpu] Run pylint check of gpu tests in unittest instead of PRESUBMIT

third_party/pylint/pylint/checkers/variables.py

Index: third_party/pylint/pylint/checkers/variables.py
diff --git a/third_party/pylint/pylint/checkers/variables.py b/third_party/pylint/pylint/checkers/variables.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f6f95743226d934f9cbc0442ed8793e8836a69e
--- /dev/null
+++ b/third_party/pylint/pylint/checkers/variables.py
@@ -0,0 +1,1069 @@
+# Copyright (c) 2003-2014 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+"""variables checkers for Python code
+"""
+import os
+import sys
+import re
+from copy import copy
+
+import astroid
+from astroid import are_exclusive, builtin_lookup
+from astroid import modutils
+
+from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE, HIGH
+from pylint.utils import get_global_option
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import (
+    PYMETHODS, is_ancestor_name, is_builtin,
+    is_defined_before, is_error, is_func_default, is_func_decorator,
+    assign_parent, check_messages, is_inside_except, clobber_in_except,
+    get_all_elements, has_known_bases)
+import six
+
+SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
+
+PY3K = sys.version_info >= (3, 0)
+
+def in_for_else_branch(parent, stmt):
+    """Returns True if stmt in inside the else branch for a parent For stmt."""
+    return (isinstance(parent, astroid.For) and
+            any(else_stmt.parent_of(stmt) for else_stmt in parent.orelse))
+
+def overridden_method(klass, name):
+    """get overridden method if any"""
+    try:
+        parent = next(klass.local_attr_ancestors(name))
+    except (StopIteration, KeyError):
+        return None
+    try:
+        meth_node = parent[name]
+    except KeyError:
+        # We have found an ancestor defining <name> but it's not in the local
+        # dictionary. This may happen with astroid built from living objects.
+        return None
+    if isinstance(meth_node, astroid.Function):
+        return meth_node
+    return None
+
+def _get_unpacking_extra_info(node, infered):
+    """return extra information to add to the message for unpacking-non-sequence
+    and unbalanced-tuple-unpacking errors
+    """
+    more = ''
+    infered_module = infered.root().name
+    if node.root().name == infered_module:
+        if node.lineno == infered.lineno:
+            more = ' %s' % infered.as_string()
+        elif infered.lineno:
+            more = ' defined at line %s' % infered.lineno
+    elif infered.lineno:
+        more = ' defined at line %s of %s' % (infered.lineno, infered_module)
+    return more
+
+def _detect_global_scope(node, frame, defframe):
+    """ Detect that the given frames shares a global
+    scope.
+
+    Two frames shares a global scope when neither
+    of them are hidden under a function scope, as well
+    as any of parent scope of them, until the root scope.
+    In this case, depending from something defined later on
+    will not work, because it is still undefined.
+
+    Example:
+        class A:
+            # B has the same global scope as `C`, leading to a NameError.
+            class B(C): ...
+        class C: ...
+
+    """
+    def_scope = scope = None
+    if frame and frame.parent:
+        scope = frame.parent.scope()
+    if defframe and defframe.parent:
+        def_scope = defframe.parent.scope()
+    if isinstance(frame, astroid.Function):
+        # If the parent of the current node is a
+        # function, then it can be under its scope
+        # (defined in, which doesn't concern us) or
+        # the `->` part of annotations. The same goes
+        # for annotations of function arguments, they'll have
+        # their parent the Arguments node.
+        if not isinstance(node.parent,
+                          (astroid.Function, astroid.Arguments)):
+            return False
+    elif any(not isinstance(f, (astroid.Class, astroid.Module))
+             for f in (frame, defframe)):
+        # Not interested in other frames, since they are already
+        # not in a global scope.
+        return False
+
+    break_scopes = []
+    for s in (scope, def_scope):
+        # Look for parent scopes. If there is anything different
+        # than a module or a class scope, then they frames don't
+        # share a global scope.
+        parent_scope = s
+        while parent_scope:
+            if not isinstance(parent_scope, (astroid.Class, astroid.Module)):
+                break_scopes.append(parent_scope)
+                break
+            if parent_scope.parent:
+                parent_scope = parent_scope.parent.scope()
+            else:
+                break
+    if break_scopes and len(set(break_scopes)) != 1:
+        # Store different scopes than expected.
+        # If the stored scopes are, in fact, the very same, then it means
+        # that the two frames (frame and defframe) shares the same scope,
+        # and we could apply our lineno analysis over them.
+        # For instance, this works when they are inside a function, the node
+        # that uses a definition and the definition itself.
+        return False
+    # At this point, we are certain that frame and defframe shares a scope
+    # and the definition of the first depends on the second.
+    return frame.lineno < defframe.lineno
+
+def _fix_dot_imports(not_consumed):
+    """ Try to fix imports with multiple dots, by returning a dictionary
+    with the import names expanded. The function unflattens root imports,
+    like 'xml' (when we have both 'xml.etree' and 'xml.sax'), to 'xml.etree'
+    and 'xml.sax' respectively.
+    """
+    # TODO: this should be improved in issue astroid #46
+    names = {}
+    for name, stmts in six.iteritems(not_consumed):
+        if any(isinstance(stmt, astroid.AssName)
+               and isinstance(stmt.ass_type(), astroid.AugAssign)
+               for stmt in stmts):
+            continue
+        for stmt in stmts:
+            if not isinstance(stmt, (astroid.From, astroid.Import)):
+                continue
+            for imports in stmt.names:
+                second_name = None
+                if imports[0] == "*":
+                    # In case of wildcard imports,
+                    # pick the name from inside the imported module.
+                    second_name = name
+                else:
+                    if imports[0].find(".") > -1 or name in imports:
+                        # Most likely something like 'xml.etree',
+                        # which will appear in the .locals as 'xml'.
+                        # Only pick the name if it wasn't consumed.
+                        second_name = imports[0]
+                if second_name and second_name not in names:
+                    names[second_name] = stmt
+    return sorted(names.items(), key=lambda a: a[1].fromlineno)
+
+def _find_frame_imports(name, frame):
+    """
+    Detect imports in the frame, with the required
+    *name*. Such imports can be considered assignments.
+    Returns True if an import for the given name was found.
+    """
+    imports = frame.nodes_of_class((astroid.Import, astroid.From))
+    for import_node in imports:
+        for import_name, import_alias in import_node.names:
+            # If the import uses an alias, check only that.
+            # Otherwise, check only the import name.
+            if import_alias:
+                if import_alias == name:
+                    return True
+            elif import_name and import_name == name:
+                return True
+
+
+MSGS = {
+    'E0601': ('Using variable %r before assignment',
+              'used-before-assignment',
+              'Used when a local variable is accessed before it\'s \
+              assignment.'),
+    'E0602': ('Undefined variable %r',
+              'undefined-variable',
+              'Used when an undefined variable is accessed.'),
+    'E0603': ('Undefined variable name %r in __all__',
+              'undefined-all-variable',
+              'Used when an undefined variable name is referenced in __all__.'),
+    'E0604': ('Invalid object %r in __all__, must contain only strings',
+              'invalid-all-object',
+              'Used when an invalid (non-string) object occurs in __all__.'),
+    'E0611': ('No name %r in module %r',
+              'no-name-in-module',
+              'Used when a name cannot be found in a module.'),
+
+    'W0601': ('Global variable %r undefined at the module level',
+              'global-variable-undefined',
+              'Used when a variable is defined through the "global" statement \
+              but the variable is not defined in the module scope.'),
+    'W0602': ('Using global for %r but no assignment is done',
+              'global-variable-not-assigned',
+              'Used when a variable is defined through the "global" statement \
+              but no assignment to this variable is done.'),
+    'W0603': ('Using the global statement', # W0121
+              'global-statement',
+              'Used when you use the "global" statement to update a global \
+              variable. Pylint just try to discourage this \
+              usage. That doesn\'t mean you can not use it !'),
+    'W0604': ('Using the global statement at the module level', # W0103
+              'global-at-module-level',
+              'Used when you use the "global" statement at the module level \
+              since it has no effect'),
+    'W0611': ('Unused %s',
+              'unused-import',
+              'Used when an imported module or variable is not used.'),
+    'W0612': ('Unused variable %r',
+              'unused-variable',
+              'Used when a variable is defined but not used.'),
+    'W0613': ('Unused argument %r',
+              'unused-argument',
+              'Used when a function or method argument is not used.'),
+    'W0614': ('Unused import %s from wildcard import',
+              'unused-wildcard-import',
+              'Used when an imported module or variable is not used from a \
+              \'from X import *\' style import.'),
+
+    'W0621': ('Redefining name %r from outer scope (line %s)',
+              'redefined-outer-name',
+              'Used when a variable\'s name hide a name defined in the outer \
+              scope.'),
+    'W0622': ('Redefining built-in %r',
+              'redefined-builtin',
+              'Used when a variable or function override a built-in.'),
+    'W0623': ('Redefining name %r from %s in exception handler',
+              'redefine-in-handler',
+              'Used when an exception handler assigns the exception \
+               to an existing name'),
+
+    'W0631': ('Using possibly undefined loop variable %r',
+              'undefined-loop-variable',
+              'Used when an loop variable (i.e. defined by a for loop or \
+              a list comprehension or a generator expression) is used outside \
+              the loop.'),
+
+    'W0632': ('Possible unbalanced tuple unpacking with '
+              'sequence%s: '
+              'left side has %d label(s), right side has %d value(s)',
+              'unbalanced-tuple-unpacking',
+              'Used when there is an unbalanced tuple unpacking in assignment'),
+
+    'W0633': ('Attempting to unpack a non-sequence%s',
+              'unpacking-non-sequence',
+              'Used when something which is not '
+              'a sequence is used in an unpack assignment'),
+
+    'W0640': ('Cell variable %s defined in loop',
+              'cell-var-from-loop',
+              'A variable used in a closure is defined in a loop. '
+              'This will result in all closures using the same value for '
+              'the closed-over variable.'),
+
+    }
+
+class VariablesChecker(BaseChecker):
+    """checks for
+    * unused variables / imports
+    * undefined variables
+    * redefinition of variable from builtins or from an outer scope
+    * use of variable before assignment
+    * __all__ consistency
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = 'variables'
+    msgs = MSGS
+    priority = -1
+    options = (("init-import",
+                {'default': 0, 'type' : 'yn', 'metavar' : '<y_or_n>',
+                 'help' : 'Tells whether we should check for unused import in \
+__init__ files.'}),
+               ("dummy-variables-rgx",
+                {'default': ('_$|dummy'),
+                 'type' :'regexp', 'metavar' : '<regexp>',
+                 'help' : 'A regular expression matching the name of dummy \
+variables (i.e. expectedly not used).'}),
+               ("additional-builtins",
+                {'default': (), 'type' : 'csv',
+                 'metavar' : '<comma separated list>',
+                 'help' : 'List of additional names supposed to be defined in \
+builtins. Remember that you should avoid to define new builtins when possible.'
+                }),
+               ("callbacks",
+                {'default' : ('cb_', '_cb'), 'type' : 'csv',
+                 'metavar' : '<callbacks>',
+                 'help' : 'List of strings which can identify a callback '
+                          'function by name. A callback name must start or '
+                          'end with one of those strings.'}
+               )
+              )
+    def __init__(self, linter=None):
+        BaseChecker.__init__(self, linter)
+        self._to_consume = None
+        self._checking_mod_attr = None
+
+    def visit_module(self, node):
+        """visit module : update consumption analysis variable
+        checks globals doesn't overrides builtins
+        """
+        self._to_consume = [(copy(node.locals), {}, 'module')]
+        for name, stmts in six.iteritems(node.locals):
+            if is_builtin(name) and not is_inside_except(stmts[0]):
+                # do not print Redefining builtin for additional builtins
+                self.add_message('redefined-builtin', args=name, node=stmts[0])
+
+    @check_messages('unused-import', 'unused-wildcard-import',
+                    'redefined-builtin', 'undefined-all-variable',
+                    'invalid-all-object')
+    def leave_module(self, node):
+        """leave module: check globals
+        """
+        assert len(self._to_consume) == 1
+        not_consumed = self._to_consume.pop()[0]
+        # attempt to check for __all__ if defined
+        if '__all__' in node.locals:
+            assigned = next(node.igetattr('__all__'))
+            if assigned is not astroid.YES:
+                for elt in getattr(assigned, 'elts', ()):
+                    try:
+                        elt_name = next(elt.infer())
+                    except astroid.InferenceError:
+                        continue
+
+                    if not isinstance(elt_name, astroid.Const) \
+                             or not isinstance(elt_name.value, six.string_types):
+                        self.add_message('invalid-all-object',
+                                         args=elt.as_string(), node=elt)
+                        continue
+                    elt_name = elt_name.value
+                    # If elt is in not_consumed, remove it from not_consumed
+                    if elt_name in not_consumed:
+                        del not_consumed[elt_name]
+                        continue
+                    if elt_name not in node.locals:
+                        if not node.package:
+                            self.add_message('undefined-all-variable',
+                                             args=elt_name,
+                                             node=elt)
+                        else:
+                            basename = os.path.splitext(node.file)[0]
+                            if os.path.basename(basename) == '__init__':
+                                name = node.name + "." + elt_name
+                                try:
+                                    modutils.file_from_modpath(name.split("."))
+                                except ImportError:
+                                    self.add_message('undefined-all-variable',
+                                                     args=elt_name,
+                                                     node=elt)
+                                except SyntaxError:
+                                    # don't yield an syntax-error warning,
+                                    # because it will be later yielded
+                                    # when the file will be checked
+                                    pass
+        # don't check unused imports in __init__ files
+        if not self.config.init_import and node.package:
+            return
+
+        self._check_imports(not_consumed)
+
+    def _check_imports(self, not_consumed):
+        local_names = _fix_dot_imports(not_consumed)
+        checked = set()
+        for name, stmt in local_names:
+            for imports in stmt.names:
+                real_name = imported_name = imports[0]
+                if imported_name == "*":
+                    real_name = name
+                as_name = imports[1]
+                if real_name in checked:
+                    continue
+                if name not in (real_name, as_name):
+                    continue
+                checked.add(real_name)
+
+                if (isinstance(stmt, astroid.Import) or
+                        (isinstance(stmt, astroid.From) and
+                         not stmt.modname)):
+                    if (isinstance(stmt, astroid.From) and
+                            SPECIAL_OBJ.search(imported_name)):
+                        # Filter special objects (__doc__, __all__) etc.,
+                        # because they can be imported for exporting.
+                        continue
+                    if as_name is None:
+                        msg = "import %s" % imported_name
+                    else:
+                        msg = "%s imported as %s" % (imported_name, as_name)
+                    self.add_message('unused-import', args=msg, node=stmt)
+                elif isinstance(stmt, astroid.From) and stmt.modname != '__future__':
+                    if SPECIAL_OBJ.search(imported_name):
+                        # Filter special objects (__doc__, __all__) etc.,
+                        # because they can be imported for exporting.
+                        continue
+                    if imported_name == '*':
+                        self.add_message('unused-wildcard-import',
+                                         args=name, node=stmt)
+                    else:
+                        if as_name is None:
+                            msg = "%s imported from %s" % (imported_name, stmt.modname)
+                        else:
+                            fields = (imported_name, stmt.modname, as_name)
+                            msg = "%s imported from %s as %s" % fields
+                        self.add_message('unused-import', args=msg, node=stmt)
+        del self._to_consume
+
+    def visit_class(self, node):
+        """visit class: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'class'))
+
+    def leave_class(self, _):
+        """leave class: update consumption analysis variable
+        """
+        # do not check for not used locals here (no sense)
+        self._to_consume.pop()
+
+    def visit_lambda(self, node):
+        """visit lambda: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'lambda'))
+
+    def leave_lambda(self, _):
+        """leave lambda: update consumption analysis variable
+        """
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_genexpr(self, node):
+        """visit genexpr: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
+
+    def leave_genexpr(self, _):
+        """leave genexpr: update consumption analysis variable
+        """
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_dictcomp(self, node):
+        """visit dictcomp: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
+
+    def leave_dictcomp(self, _):
+        """leave dictcomp: update consumption analysis variable
+        """
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_setcomp(self, node):
+        """visit setcomp: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
+
+    def leave_setcomp(self, _):
+        """leave setcomp: update consumption analysis variable
+        """
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def visit_function(self, node):
+        """visit function: update consumption analysis variable and check locals
+        """
+        self._to_consume.append((copy(node.locals), {}, 'function'))
+        if not (self.linter.is_message_enabled('redefined-outer-name') or
+                self.linter.is_message_enabled('redefined-builtin')):
+            return
+        globs = node.root().globals
+        for name, stmt in node.items():
+            if is_inside_except(stmt):
+                continue
+            if name in globs and not isinstance(stmt, astroid.Global):
+                line = globs[name][0].fromlineno
+                dummy_rgx = self.config.dummy_variables_rgx
+                if not dummy_rgx.match(name):
+                    self.add_message('redefined-outer-name', args=(name, line), node=stmt)
+            elif is_builtin(name):
+                # do not print Redefining builtin for additional builtins
+                self.add_message('redefined-builtin', args=name, node=stmt)
+
+    def leave_function(self, node):
+        """leave function: check function's locals are consumed"""
+        not_consumed = self._to_consume.pop()[0]
+        if not (self.linter.is_message_enabled('unused-variable') or
+                self.linter.is_message_enabled('unused-argument')):
+            return
+        # don't check arguments of function which are only raising an exception
+        if is_error(node):
+            return
+        # don't check arguments of abstract methods or within an interface
+        is_method = node.is_method()
+        klass = node.parent.frame()
+        if is_method and (klass.type == 'interface' or node.is_abstract()):
+            return
+        if is_method and isinstance(klass, astroid.Class):
+            confidence = INFERENCE if has_known_bases(klass) else INFERENCE_FAILURE
+        else:
+            confidence = HIGH
+        authorized_rgx = self.config.dummy_variables_rgx
+        called_overridden = False
+        argnames = node.argnames()
+        global_names = set()
+        nonlocal_names = set()
+        for global_stmt in node.nodes_of_class(astroid.Global):
+            global_names.update(set(global_stmt.names))
+        for nonlocal_stmt in node.nodes_of_class(astroid.Nonlocal):
+            nonlocal_names.update(set(nonlocal_stmt.names))
+
+        for name, stmts in six.iteritems(not_consumed):
+            # ignore some special names specified by user configuration
+            if authorized_rgx.match(name):
+                continue
+            # ignore names imported by the global statement
+            # FIXME: should only ignore them if it's assigned latter
+            stmt = stmts[0]
+            if isinstance(stmt, astroid.Global):
+                continue
+            if isinstance(stmt, (astroid.Import, astroid.From)):
+                # Detect imports, assigned to global statements.
+                if global_names:
+                    skip = False
+                    for import_name, import_alias in stmt.names:
+                        # If the import uses an alias, check only that.
+                        # Otherwise, check only the import name.
+                        if import_alias:
+                            if import_alias in global_names:
+                                skip = True
+                                break
+                        elif import_name in global_names:
+                            skip = True
+                            break
+                    if skip:
+                        continue
+
+            # care about functions with unknown argument (builtins)
+            if name in argnames:
+                if is_method:
+                    # don't warn for the first argument of a (non static) method
+                    if node.type != 'staticmethod' and name == argnames[0]:
+                        continue
+                    # don't warn for argument of an overridden method
+                    if not called_overridden:
+                        overridden = overridden_method(klass, node.name)
+                        called_overridden = True
+                    if overridden is not None and name in overridden.argnames():
+                        continue
+                    if node.name in PYMETHODS and node.name not in ('__init__', '__new__'):
+                        continue
+                # don't check callback arguments
+                if any(node.name.startswith(cb) or node.name.endswith(cb)
+                       for cb in self.config.callbacks):
+                    continue
+                self.add_message('unused-argument', args=name, node=stmt,
+                                 confidence=confidence)
+            else:
+                if stmt.parent and isinstance(stmt.parent, astroid.Assign):
+                    if name in nonlocal_names:
+                        continue
+                self.add_message('unused-variable', args=name, node=stmt)
+
+    @check_messages('global-variable-undefined', 'global-variable-not-assigned', 'global-statement',
+                    'global-at-module-level', 'redefined-builtin')
+    def visit_global(self, node):
+        """check names imported exists in the global scope"""
+        frame = node.frame()
+        if isinstance(frame, astroid.Module):
+            self.add_message('global-at-module-level', node=node)
+            return
+        module = frame.root()
+        default_message = True
+        for name in node.names:
+            try:
+                assign_nodes = module.getattr(name)
+            except astroid.NotFoundError:
+                # unassigned global, skip
+                assign_nodes = []
+            for anode in assign_nodes:
+                if anode.parent is None:
+                    # node returned for builtin attribute such as __file__,
+                    # __doc__, etc...
+                    continue
+                if anode.frame() is frame:
+                    # same scope level assignment
+                    break
+            else:
+                if not _find_frame_imports(name, frame):
+                    self.add_message('global-variable-not-assigned',
+                                     args=name, node=node)
+                default_message = False
+            if not assign_nodes:
+                continue
+            for anode in assign_nodes:
+                if anode.parent is None:
+                    self.add_message('redefined-builtin', args=name, node=node)
+                    break
+                if anode.frame() is module:
+                    # module level assignment
+                    break
+            else:
+                # global undefined at the module scope
+                self.add_message('global-variable-undefined', args=name, node=node)
+                default_message = False
+        if default_message:
+            self.add_message('global-statement', node=node)
+
+    def _check_late_binding_closure(self, node, assignment_node):
+        def _is_direct_lambda_call():
+            return (isinstance(node_scope.parent, astroid.CallFunc)
+                    and node_scope.parent.func is node_scope)
+
+        node_scope = node.scope()
+        if not isinstance(node_scope, (astroid.Lambda, astroid.Function)):
+            return
+        if isinstance(node.parent, astroid.Arguments):
+            return
+
+        if isinstance(assignment_node, astroid.Comprehension):
+            if assignment_node.parent.parent_of(node.scope()):
+                self.add_message('cell-var-from-loop', node=node, args=node.name)
+        else:
+            assign_scope = assignment_node.scope()
+            maybe_for = assignment_node
+            while not isinstance(maybe_for, astroid.For):
+                if maybe_for is assign_scope:
+                    break
+                maybe_for = maybe_for.parent
+            else:
+                if (maybe_for.parent_of(node_scope)
+                        and not _is_direct_lambda_call()
+                        and not isinstance(node_scope.statement(), astroid.Return)):
+                    self.add_message('cell-var-from-loop', node=node, args=node.name)
+
+    def _loopvar_name(self, node, name):
+        # filter variables according to node's scope
+        # XXX used to filter parents but don't remember why, and removing this
+        # fixes a W0631 false positive reported by Paul Hachmann on 2008/12 on
+        # python-projects (added to func_use_for_or_listcomp_var test)
+        #astmts = [stmt for stmt in node.lookup(name)[1]
+        #          if hasattr(stmt, 'ass_type')] and
+        #          not stmt.statement().parent_of(node)]
+        if not self.linter.is_message_enabled('undefined-loop-variable'):
+            return
+        astmts = [stmt for stmt in node.lookup(name)[1]
+                  if hasattr(stmt, 'ass_type')]
+        # filter variables according their respective scope test is_statement
+        # and parent to avoid #74747. This is not a total fix, which would
+        # introduce a mechanism similar to special attribute lookup in
+        # modules. Also, in order to get correct inference in this case, the
+        # scope lookup rules would need to be changed to return the initial
+        # assignment (which does not exist in code per se) as well as any later
+        # modifications.
+        if not astmts or (astmts[0].is_statement or astmts[0].parent) \
+             and astmts[0].statement().parent_of(node):
+            _astmts = []
+        else:
+            _astmts = astmts[:1]
+        for i, stmt in enumerate(astmts[1:]):
+            if (astmts[i].statement().parent_of(stmt)
+                    and not in_for_else_branch(astmts[i].statement(), stmt)):
+                continue
+            _astmts.append(stmt)
+        astmts = _astmts
+        if len(astmts) == 1:
+            ass = astmts[0].ass_type()
+            if isinstance(ass, (astroid.For, astroid.Comprehension, astroid.GenExpr)) \
+                   and not ass.statement() is node.statement():
+                self.add_message('undefined-loop-variable', args=name, node=node)
+
+    @check_messages('redefine-in-handler')
+    def visit_excepthandler(self, node):
+        for name in get_all_elements(node.name):
+            clobbering, args = clobber_in_except(name)
+            if clobbering:
+                self.add_message('redefine-in-handler', args=args, node=name)
+
+    def visit_assname(self, node):
+        if isinstance(node.ass_type(), astroid.AugAssign):
+            self.visit_name(node)
+
+    def visit_delname(self, node):
+        self.visit_name(node)
+
+    @check_messages(*(MSGS.keys()))
+    def visit_name(self, node):
+        """check that a name is defined if the current scope and doesn't
+        redefine a built-in
+        """
+        stmt = node.statement()
+        if stmt.fromlineno is None:
+            # name node from a astroid built from live code, skip
+            assert not stmt.root().file.endswith('.py')
+            return
+        name = node.name
+        frame = stmt.scope()
+        # if the name node is used as a function default argument's value or as
+        # a decorator, then start from the parent frame of the function instead
+        # of the function frame - and thus open an inner class scope
+        if (is_func_default(node) or is_func_decorator(node)
+                or is_ancestor_name(frame, node)):
+            start_index = len(self._to_consume) - 2
+        else:
+            start_index = len(self._to_consume) - 1
+        # iterates through parent scopes, from the inner to the outer
+        base_scope_type = self._to_consume[start_index][-1]
+        for i in range(start_index, -1, -1):
+            to_consume, consumed, scope_type = self._to_consume[i]
+            # if the current scope is a class scope but it's not the inner
+            # scope, ignore it. This prevents to access this scope instead of
+            # the globals one in function members when there are some common
+            # names. The only exception is when the starting scope is a
+            # comprehension and its direct outer scope is a class
+            if scope_type == 'class' and i != start_index and not (
+                    base_scope_type == 'comprehension' and i == start_index-1):
+                # Detect if we are in a local class scope, as an assignment.
+                # For example, the following is fair game.
+                #
+                # class A:
+                #    b = 1
+                #    c = lambda b=b: b * b
+                #
+                # class B:
+                #    tp = 1
+                #    def func(self, arg: tp):
+                #        ...
+
+                in_annotation = (
+                    PY3K and isinstance(frame, astroid.Function)
+                    and node.statement() is frame and
+                    (node in frame.args.annotations
+                     or node is frame.args.varargannotation
+                     or node is frame.args.kwargannotation))
+                if in_annotation:
+                    frame_locals = frame.parent.scope().locals
+                else:
+                    frame_locals = frame.locals
+                if not ((isinstance(frame, astroid.Class) or in_annotation)
+                        and name in frame_locals):
+                    continue
+            # the name has already been consumed, only check it's not a loop
+            # variable used outside the loop
+            if name in consumed:
+                defnode = assign_parent(consumed[name][0])
+                self._check_late_binding_closure(node, defnode)
+                self._loopvar_name(node, name)
+                break
+            # mark the name as consumed if it's defined in this scope
+            # (i.e. no KeyError is raised by "to_consume[name]")
+            try:
+                consumed[name] = to_consume[name]
+            except KeyError:
+                continue
+            # checks for use before assignment
+            defnode = assign_parent(to_consume[name][0])
+            if defnode is not None:
+                self._check_late_binding_closure(node, defnode)
+                defstmt = defnode.statement()
+                defframe = defstmt.frame()
+                maybee0601 = True
+                if not frame is defframe:
+                    maybee0601 = _detect_global_scope(node, frame, defframe)
+                elif defframe.parent is None:
+                    # we are at the module level, check the name is not
+                    # defined in builtins
+                    if name in defframe.scope_attrs or builtin_lookup(name)[1]:
+                        maybee0601 = False
+                else:
+                    # we are in a local scope, check the name is not
+                    # defined in global or builtin scope
+                    if defframe.root().lookup(name)[1]:
+                        maybee0601 = False
+                    else:
+                        # check if we have a nonlocal
+                        if name in defframe.locals:
+                            maybee0601 = not any(isinstance(child, astroid.Nonlocal)
+                                                 and name in child.names
+                                                 for child in defframe.get_children())
+
+                # Handle a couple of class scoping issues.
+                annotation_return = False
+                # The class reuses itself in the class scope.
+                recursive_klass = (frame is defframe and
+                                   defframe.parent_of(node) and
+                                   isinstance(defframe, astroid.Class) and
+                                   node.name == defframe.name)
+                if (self._to_consume[-1][-1] == 'lambda' and
+                        isinstance(frame, astroid.Class)
+                        and name in frame.locals):
+                    maybee0601 = True
+                elif (isinstance(defframe, astroid.Class) and
+                      isinstance(frame, astroid.Function)):
+                    # Special rule for function return annotations,
+                    # which uses the same name as the class where
+                    # the function lives.
+                    if (PY3K and node is frame.returns and
+                            defframe.parent_of(frame.returns)):
+                        maybee0601 = annotation_return = True
+
+                    if (maybee0601 and defframe.name in defframe.locals and
+                            defframe.locals[name][0].lineno < frame.lineno):
+                        # Detect class assignments with the same
+                        # name as the class. In this case, no warning
+                        # should be raised.
+                        maybee0601 = False
+                elif recursive_klass:
+                    maybee0601 = True
+                else:
+                    maybee0601 = maybee0601 and stmt.fromlineno <= defstmt.fromlineno
+
+                if (maybee0601
+                        and not is_defined_before(node)
+                        and not are_exclusive(stmt, defstmt, ('NameError',
+                                                              'Exception',
+                                                              'BaseException'))):
+                    if recursive_klass or (defstmt is stmt and
+                                           isinstance(node, (astroid.DelName,
+                                                             astroid.AssName))):
+                        self.add_message('undefined-variable', args=name, node=node)
+                    elif annotation_return:
+                        self.add_message('undefined-variable', args=name, node=node)
+                    elif self._to_consume[-1][-1] != 'lambda':
+                        # E0601 may *not* occurs in lambda scope.
+                        self.add_message('used-before-assignment', args=name, node=node)
+                    elif self._to_consume[-1][-1] == 'lambda':
+                        # E0601 can occur in class-level scope in lambdas, as in
+                        # the following example:
+                        #   class A:
+                        #      x = lambda attr: f + attr
+                        #      f = 42
+                        if isinstance(frame, astroid.Class) and name in frame.locals:
+                            if isinstance(node.parent, astroid.Arguments):
+                                # Doing the following is fine:
+                                #   class A:
+                                #      x = 42
+                                #      y = lambda attr=x: attr
+                                if stmt.fromlineno <= defstmt.fromlineno:
+                                    self.add_message('used-before-assignment',
+                                                     args=name, node=node)
+                            else:
+                                self.add_message('undefined-variable',
+                                                 args=name, node=node)
+
+            if isinstance(node, astroid.AssName): # Aug AssName
+                del consumed[name]
+            else:
+                del to_consume[name]
+            # check it's not a loop variable used outside the loop
+            self._loopvar_name(node, name)
+            break
+        else:
+            # we have not found the name, if it isn't a builtin, that's an
+            # undefined name !
+            if not (name in astroid.Module.scope_attrs or is_builtin(name)
+                    or name in self.config.additional_builtins):
+                self.add_message('undefined-variable', args=name, node=node)
+
+    @check_messages('no-name-in-module')
+    def visit_import(self, node):
+        """check modules attribute accesses"""
+        for name, _ in node.names:
+            parts = name.split('.')
+            try:
+                module = next(node.infer_name_module(parts[0]))
+            except astroid.ResolveError:
+                continue
+            self._check_module_attrs(node, module, parts[1:])
+
+    @check_messages('no-name-in-module')
+    def visit_from(self, node):
+        """check modules attribute accesses"""
+        name_parts = node.modname.split('.')
+        level = getattr(node, 'level', None)
+        try:
+            module = node.root().import_module(name_parts[0], level=level)
+        except Exception: # pylint: disable=broad-except
+            return
+        module = self._check_module_attrs(node, module, name_parts[1:])
+        if not module:
+            return
+        for name, _ in node.names:
+            if name == '*':
+                continue
+            self._check_module_attrs(node, module, name.split('.'))
+
+    @check_messages('unbalanced-tuple-unpacking', 'unpacking-non-sequence')
+    def visit_assign(self, node):
+        """Check unbalanced tuple unpacking for assignments
+        and unpacking non-sequences.
+        """
+        if not isinstance(node.targets[0], (astroid.Tuple, astroid.List)):
+            return
+
+        targets = node.targets[0].itered()
+        try:
+            for infered in node.value.infer():
+                self._check_unpacking(infered, node, targets)
+        except astroid.InferenceError:
+            return
+
+    def _check_unpacking(self, infered, node, targets):
+        """ Check for unbalanced tuple unpacking
+        and unpacking non sequences.
+        """
+        if infered is astroid.YES:
+            return
+        if (isinstance(infered.parent, astroid.Arguments) and
+                isinstance(node.value, astroid.Name) and
+                node.value.name == infered.parent.vararg):
+            # Variable-length argument, we can't determine the length.
+            return
+        if isinstance(infered, (astroid.Tuple, astroid.List)):
+            # attempt to check unpacking is properly balanced
+            values = infered.itered()
+            if len(targets) != len(values):
+                # Check if we have starred nodes.
+                if any(isinstance(target, astroid.Starred)
+                       for target in targets):
+                    return
+                self.add_message('unbalanced-tuple-unpacking', node=node,
+                                 args=(_get_unpacking_extra_info(node, infered),
+                                       len(targets),
+                                       len(values)))
+        # attempt to check unpacking may be possible (ie RHS is iterable)
+        elif isinstance(infered, astroid.Instance):
+            for meth in ('__iter__', '__getitem__'):
+                try:
+                    infered.getattr(meth)
+                    break
+                except astroid.NotFoundError:
+                    continue
+            else:
+                self.add_message('unpacking-non-sequence', node=node,
+                                 args=(_get_unpacking_extra_info(node, infered),))
+        else:
+            self.add_message('unpacking-non-sequence', node=node,
+                             args=(_get_unpacking_extra_info(node, infered),))
+
+
+    def _check_module_attrs(self, node, module, module_names):
+        """check that module_names (list of string) are accessible through the
+        given module
+        if the latest access name corresponds to a module, return it
+        """
+        assert isinstance(module, astroid.Module), module
+        ignored_modules = get_global_option(self, 'ignored-modules',
+                                            default=[])
+        while module_names:
+            name = module_names.pop(0)
+            if name == '__dict__':
+                module = None
+                break
+            try:
+                module = next(module.getattr(name)[0].infer())
+                if module is astroid.YES:
+                    return None
+            except astroid.NotFoundError:
+                if module.name in ignored_modules:
+                    return None
+                self.add_message('no-name-in-module',
+                                 args=(name, module.name), node=node)
+                return None
+            except astroid.InferenceError:
+                return None
+        if module_names:
+            # FIXME: other message if name is not the latest part of
+            # module_names ?
+            modname = module and module.name or '__dict__'
+            self.add_message('no-name-in-module', node=node,
+                             args=('.'.join(module_names), modname))
+            return None
+        if isinstance(module, astroid.Module):
+            return module
+        return None
+
+
+class VariablesChecker3k(VariablesChecker):
+    '''Modified variables checker for 3k'''
+    # listcomp have now also their scope
+
+    def visit_listcomp(self, node):
+        """visit dictcomp: update consumption analysis variable
+        """
+        self._to_consume.append((copy(node.locals), {}, 'comprehension'))
+
+    def leave_listcomp(self, _):
+        """leave dictcomp: update consumption analysis variable
+        """
+        # do not check for not used locals here
+        self._to_consume.pop()
+
+    def leave_module(self, node):
+        """ Update consumption analysis variable
+        for metaclasses.
+        """
+        module_locals = self._to_consume[0][0]
+        module_imports = self._to_consume[0][1]
+        consumed = {}
+
+        for klass in node.nodes_of_class(astroid.Class):
+            found = metaclass = name = None
+            if not klass._metaclass:
+                # Skip if this class doesn't use
+                # explictly a metaclass, but inherits it from ancestors
+                continue
+
+            metaclass = klass.metaclass()
+
+            # Look the name in the already found locals.
+            # If it's not found there, look in the module locals
+            # and in the imported modules.
+            if isinstance(klass._metaclass, astroid.Name):
+                name = klass._metaclass.name
+            elif metaclass:
+                # if it uses a `metaclass=module.Class`
+                name = metaclass.root().name
+
+            if name:
+                found = consumed.setdefault(
+                    name, module_locals.get(name, module_imports.get(name)))
+
+            if found is None and not metaclass:
+                name = None
+                if isinstance(klass._metaclass, astroid.Name):
+                    name = klass._metaclass.name
+                elif isinstance(klass._metaclass, astroid.Getattr):
+                    name = klass._metaclass.as_string()
+
+                if name is not None:
+                    if not (name in astroid.Module.scope_attrs or
+                            is_builtin(name) or
+                            name in self.config.additional_builtins or
+                            name in node.locals):
+                        self.add_message('undefined-variable',
+                                         node=klass,
+                                         args=(name, ))
+        # Pop the consumed items, in order to
+        # avoid having unused-import false positives
+        for name in consumed:
+            module_locals.pop(name, None)
+        super(VariablesChecker3k, self).leave_module(node)
+
+if sys.version_info >= (3, 0):
+    VariablesChecker = VariablesChecker3k
+
+
+def register(linter):
+    """required method to auto register this checker"""
+    linter.register_checker(VariablesChecker(linter))