libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -20,10 +20,10 @@ import sys
 import re
 from copy import copy
 
+import six
+
 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
@@ -31,13 +31,28 @@ 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
+    get_all_elements, has_known_bases, node_ignores_exception,
+    is_inside_abstract_class, is_comprehension, is_iterable,
+    safe_infer)
 
 SPECIAL_OBJ = re.compile("^_{2}[a-z]+_{2}$")
-
+FUTURE = '__future__'
 PY3K = sys.version_info >= (3, 0)
 
+
+def _is_from_future_import(stmt, name):
+    """Check if the name is a future import from another module."""
+    try:
+        module = stmt.do_import_module(stmt.modname)
+    except astroid.InferenceError:
+        return
+
+    for local_node in module.locals.get(name, []):
+        if (isinstance(local_node, astroid.ImportFrom)
+                and local_node.modname == FUTURE):
+            return True
+
+
 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
@@ -55,7 +70,7 @@ def overridden_method(klass, name):
         # 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):
+    if isinstance(meth_node, astroid.FunctionDef):
         return meth_node
     return None
 
@@ -96,7 +111,7 @@ def _detect_global_scope(node, frame, defframe):
         scope = frame.parent.scope()
     if defframe and defframe.parent:
         def_scope = defframe.parent.scope()
-    if isinstance(frame, astroid.Function):
+    if isinstance(frame, astroid.FunctionDef):
         # 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
@@ -104,9 +119,9 @@ def _detect_global_scope(node, frame, defframe):
         # for annotations of function arguments, they'll have
         # their parent the Arguments node.
         if not isinstance(node.parent,
-                          (astroid.Function, astroid.Arguments)):
+                          (astroid.FunctionDef, astroid.Arguments)):
             return False
-    elif any(not isinstance(f, (astroid.Class, astroid.Module))
+    elif any(not isinstance(f, (astroid.ClassDef, astroid.Module))
              for f in (frame, defframe)):
         # Not interested in other frames, since they are already
         # not in a global scope.
@@ -119,7 +134,7 @@ def _detect_global_scope(node, frame, defframe):
         # share a global scope.
         parent_scope = s
         while parent_scope:
-            if not isinstance(parent_scope, (astroid.Class, astroid.Module)):
+            if not isinstance(parent_scope, (astroid.ClassDef, astroid.Module)):
                 break_scopes.append(parent_scope)
                 break
             if parent_scope.parent:
@@ -147,12 +162,12 @@ def _fix_dot_imports(not_consumed):
     # 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)
+        if any(isinstance(stmt, astroid.AssignName)
+               and isinstance(stmt.assign_type(), astroid.AugAssign)
                for stmt in stmts):
             continue
         for stmt in stmts:
-            if not isinstance(stmt, (astroid.From, astroid.Import)):
+            if not isinstance(stmt, (astroid.ImportFrom, astroid.Import)):
                 continue
             for imports in stmt.names:
                 second_name = None
@@ -176,7 +191,7 @@ def _find_frame_imports(name, frame):
     *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))
+    imports = frame.nodes_of_class((astroid.Import, astroid.ImportFrom))
     for import_node in imports:
         for import_name, import_alias in import_node.names:
             # If the import uses an alias, check only that.
@@ -235,7 +250,7 @@ MSGS = {
     '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.'),
+              `\'from X import *\'` style import.'),
 
     'W0621': ('Redefining name %r from outer scope (line %s)',
               'redefined-outer-name',
@@ -255,16 +270,18 @@ MSGS = {
               a list comprehension or a generator expression) is used outside \
               the loop.'),
 
-    'W0632': ('Possible unbalanced tuple unpacking with '
+    'E0632': ('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'),
+              'Used when there is an unbalanced tuple unpacking in assignment',
+              {'old_names': [('W0632', 'unbalanced-tuple-unpacking')]}),
 
-    'W0633': ('Attempting to unpack a non-sequence%s',
+    'E0633': ('Attempting to unpack a non-sequence%s',
               'unpacking-non-sequence',
               'Used when something which is not '
-              'a sequence is used in an unpack assignment'),
+              'a sequence is used in an unpack assignment',
+              {'old_names': [('W0633', 'unpacking-non-sequence')]}),
 
     'W0640': ('Cell variable %s defined in loop',
               'cell-var-from-loop',
@@ -313,7 +330,7 @@ builtins. Remember that you should avoid to define new builtins when possible.'
               )
     def __init__(self, linter=None):
         BaseChecker.__init__(self, linter)
-        self._to_consume = None
+        self._to_consume = None  # list of tuples: (to_consume:dict, consumed:dict, scope_type:str)
         self._checking_mod_attr = None
 
     def visit_module(self, node):
@@ -336,50 +353,61 @@ builtins. Remember that you should avoid to define new builtins when possible.'
         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
+            self._check_all(node, not_consumed)
         # 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_all(self, node, not_consumed):
+        assigned = next(node.igetattr('__all__'))
+        if assigned is astroid.YES:
+            return
+
+        for elt in getattr(assigned, 'elts', ()):
+            try:
+                elt_name = next(elt.infer())
+            except astroid.InferenceError:
+                continue
+            if elt_name is astroid.YES:
+                continue
+            if not elt_name.parent:
+                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
+
     def _check_imports(self, not_consumed):
         local_names = _fix_dot_imports(not_consumed)
         checked = set()
@@ -396,9 +424,9 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                 checked.add(real_name)
 
                 if (isinstance(stmt, astroid.Import) or
-                        (isinstance(stmt, astroid.From) and
+                        (isinstance(stmt, astroid.ImportFrom) and
                          not stmt.modname)):
-                    if (isinstance(stmt, astroid.From) and
+                    if (isinstance(stmt, astroid.ImportFrom) and
                             SPECIAL_OBJ.search(imported_name)):
                         # Filter special objects (__doc__, __all__) etc.,
                         # because they can be imported for exporting.
@@ -408,11 +436,19 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                     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__':
+                elif (isinstance(stmt, astroid.ImportFrom)
+                      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 _is_from_future_import(stmt, name):
+                        # Check if the name is in fact loaded from a
+                        # __future__ import in another module.
+                        continue
+
                     if imported_name == '*':
                         self.add_message('unused-wildcard-import',
                                          args=name, node=stmt)
@@ -425,12 +461,12 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                         self.add_message('unused-import', args=msg, node=stmt)
         del self._to_consume
 
-    def visit_class(self, node):
+    def visit_classdef(self, node):
         """visit class: update consumption analysis variable
         """
         self._to_consume.append((copy(node.locals), {}, 'class'))
 
-    def leave_class(self, _):
+    def leave_classdef(self, _):
         """leave class: update consumption analysis variable
         """
         # do not check for not used locals here (no sense)
@@ -447,12 +483,12 @@ builtins. Remember that you should avoid to define new builtins when possible.'
         # do not check for not used locals here
         self._to_consume.pop()
 
-    def visit_genexpr(self, node):
+    def visit_generatorexp(self, node):
         """visit genexpr: update consumption analysis variable
         """
         self._to_consume.append((copy(node.locals), {}, 'comprehension'))
 
-    def leave_genexpr(self, _):
+    def leave_generatorexp(self, _):
         """leave genexpr: update consumption analysis variable
         """
         # do not check for not used locals here
@@ -480,7 +516,7 @@ builtins. Remember that you should avoid to define new builtins when possible.'
         # do not check for not used locals here
         self._to_consume.pop()
 
-    def visit_function(self, node):
+    def visit_functiondef(self, node):
         """visit function: update consumption analysis variable and check locals
         """
         self._to_consume.append((copy(node.locals), {}, 'function'))
@@ -492,15 +528,22 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             if is_inside_except(stmt):
                 continue
             if name in globs and not isinstance(stmt, astroid.Global):
-                line = globs[name][0].fromlineno
+                definition = globs[name][0]
+                if (isinstance(definition, astroid.ImportFrom)
+                        and definition.modname == FUTURE):
+                    # It is a __future__ directive, not a symbol.
+                    continue
+
+                line = definition.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)
+                    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):
+    def leave_functiondef(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
@@ -512,9 +555,9 @@ builtins. Remember that you should avoid to define new builtins when possible.'
         # 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()):
+        if is_method and node.is_abstract():
             return
-        if is_method and isinstance(klass, astroid.Class):
+        if is_method and isinstance(klass, astroid.ClassDef):
             confidence = INFERENCE if has_known_bases(klass) else INFERENCE_FAILURE
         else:
             confidence = HIGH
@@ -537,22 +580,23 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             stmt = stmts[0]
             if isinstance(stmt, astroid.Global):
                 continue
-            if isinstance(stmt, (astroid.Import, astroid.From)):
+            if isinstance(stmt, (astroid.Import, astroid.ImportFrom)):
                 # 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:
+                if not global_names:
+                    continue
+                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
-                    if skip:
-                        continue
+                    elif import_name in global_names:
+                        skip = True
+                        break
+                if skip:
+                    continue
 
             # care about functions with unknown argument (builtins)
             if name in argnames:
@@ -580,8 +624,12 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                         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')
+    visit_asyncfunctiondef = visit_functiondef
+    leave_asyncfunctiondef = leave_functiondef
+
+    @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()
@@ -627,11 +675,11 @@ builtins. Remember that you should avoid to define new builtins when possible.'
 
     def _check_late_binding_closure(self, node, assignment_node):
         def _is_direct_lambda_call():
-            return (isinstance(node_scope.parent, astroid.CallFunc)
+            return (isinstance(node_scope.parent, astroid.Call)
                     and node_scope.parent.func is node_scope)
 
         node_scope = node.scope()
-        if not isinstance(node_scope, (astroid.Lambda, astroid.Function)):
+        if not isinstance(node_scope, (astroid.Lambda, astroid.FunctionDef)):
             return
         if isinstance(node.parent, astroid.Arguments):
             return
@@ -683,9 +731,10 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             _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():
+            assign = astmts[0].assign_type()
+            if (isinstance(assign, (astroid.For, astroid.Comprehension,
+                                    astroid.GeneratorExp))
+                    and assign.statement() is not node.statement()):
                 self.add_message('undefined-loop-variable', args=name, node=node)
 
     @check_messages('redefine-in-handler')
@@ -695,13 +744,134 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             if clobbering:
                 self.add_message('redefine-in-handler', args=args, node=name)
 
-    def visit_assname(self, node):
-        if isinstance(node.ass_type(), astroid.AugAssign):
+    def visit_assignname(self, node):
+        if isinstance(node.assign_type(), astroid.AugAssign):
             self.visit_name(node)
 
     def visit_delname(self, node):
         self.visit_name(node)
 
+    @staticmethod
+    def _defined_in_function_definition(node, frame):
+        in_annotation_or_default = False
+        if (isinstance(frame, astroid.FunctionDef) and
+                node.statement() is frame):
+            in_annotation_or_default = (
+                (
+                    PY3K and (node in frame.args.annotations
+                              or node is frame.args.varargannotation
+                              or node is frame.args.kwargannotation)
+                )
+                or
+                frame.args.parent_of(node)
+            )
+        return in_annotation_or_default
+
+    @staticmethod
+    def _next_to_consume(node, name, to_consume):
+        # mark the name as consumed if it's defined in this scope
+        found_node = to_consume.get(name)
+        if (found_node
+                and isinstance(node.parent, astroid.Assign)
+                and node.parent == found_node[0].parent):
+            lhs = found_node[0].parent.targets[0]
+            if lhs.name == name: # this name is defined in this very statement
+                found_node = None
+        return found_node
+
+    @staticmethod
+    def _is_variable_violation(node, name, defnode, stmt, defstmt,
+                               frame, defframe, base_scope_type,
+                               recursive_klass):
+        maybee0601 = True
+        annotation_return = False
+        if frame is not 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 astroid.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())
+
+        if (base_scope_type == 'lambda' and
+                isinstance(frame, astroid.ClassDef)
+                and name in frame.locals):
+
+            # This rule verifies that if the definition node of the
+            # checked name is an Arguments node and if the name
+            # is used a default value in the arguments defaults
+            # and the actual definition of the variable label
+            # is happening before the Arguments definition.
+            #
+            # bar = None
+            # foo = lambda bar=bar: bar
+            #
+            # In this case, maybee0601 should be False, otherwise
+            # it should be True.
+            maybee0601 = not (isinstance(defnode, astroid.Arguments) and
+                              node in defnode.defaults and
+                              frame.locals[name][0].fromlineno < defstmt.fromlineno)
+        elif (isinstance(defframe, astroid.ClassDef) and
+              isinstance(frame, astroid.FunctionDef)):
+            # 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
+            if isinstance(node.parent, astroid.Arguments):
+                maybee0601 = stmt.fromlineno <= defstmt.fromlineno
+        elif recursive_klass:
+            maybee0601 = True
+        else:
+            maybee0601 = maybee0601 and stmt.fromlineno <= defstmt.fromlineno
+        return maybee0601, annotation_return
+
+    def _ignore_class_scope(self, node, name, frame):
+        # 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):
+        #        ...
+        # class C:
+        #    tp = 2
+        #    def func(self, arg=tp):
+        #        ...
+
+        in_annotation_or_default = self._defined_in_function_definition(
+            node, frame)
+        if in_annotation_or_default:
+            frame_locals = frame.parent.scope().locals
+        else:
+            frame_locals = frame.locals
+        return not ((isinstance(frame, astroid.ClassDef) or
+                     in_annotation_or_default) and
+                    name in frame_locals)
+
     @check_messages(*(MSGS.keys()))
     def visit_name(self, node):
         """check that a name is defined if the current scope and doesn't
@@ -724,6 +894,7 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             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]
+        # pylint: disable=too-many-nested-blocks; refactoring this block is a pain.
         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
@@ -733,31 +904,9 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             # 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):
+                if self._ignore_class_scope(node, name, frame):
                     continue
+
             # the name has already been consumed, only check it's not a loop
             # variable used outside the loop
             if name in consumed:
@@ -765,11 +914,10 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                 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:
+            found_node = self._next_to_consume(node, name, to_consume)
+            if found_node:
+                consumed[name] = found_node
+            else:
                 continue
             # checks for use before assignment
             defnode = assign_parent(to_consume[name][0])
@@ -777,94 +925,62 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                 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
+                                   isinstance(defframe, astroid.ClassDef) 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
+
+                maybee0601, annotation_return = self._is_variable_violation(
+                    node, name, defnode, stmt, defstmt,
+                    frame, defframe,
+                    base_scope_type, recursive_klass)
 
                 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':
+                        and not astroid.are_exclusive(stmt, defstmt, ('NameError',
+                                                                      'Exception',
+                                                                      'BaseException'))):
+
+                    # Used and defined in the same place, e.g `x += 1` and `del x`
+                    defined_by_stmt = (
+                        defstmt is stmt
+                        and isinstance(node, (astroid.DelName, astroid.AssignName))
+                    )
+
+                    if (recursive_klass
+                            or defined_by_stmt
+                            or annotation_return
+                            or isinstance(defstmt, astroid.Delete)):
+                        if not node_ignores_exception(node, NameError):
+                            self.add_message('undefined-variable', args=name,
+                                             node=node)
+                    elif base_scope_type != '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':
+                    elif base_scope_type == '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(frame, astroid.ClassDef) 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:
+                                    # Doing the following is fine:
+                                    #   class A:
+                                    #      x = 42
+                                    #      y = lambda attr=x: attr
                                     self.add_message('used-before-assignment',
                                                      args=name, node=node)
                             else:
                                 self.add_message('undefined-variable',
                                                  args=name, node=node)
+                        elif scope_type == 'lambda':
+                            self.add_message('undefined-variable',
+                                             node=node, args=name)
 
-            if isinstance(node, astroid.AssName): # Aug AssName
-                del consumed[name]
-            else:
-                del to_consume[name]
+            del to_consume[name]
             # check it's not a loop variable used outside the loop
             self._loopvar_name(node, name)
             break
@@ -873,11 +989,17 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             # 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)
+                if not node_ignores_exception(node, NameError):
+                    self.add_message('undefined-variable', args=name, node=node)
 
     @check_messages('no-name-in-module')
     def visit_import(self, node):
         """check modules attribute accesses"""
+        if node_ignores_exception(node, ImportError):
+            # No need to verify this, since ImportError is already
+            # handled by the client code.
+            return
+
         for name, _ in node.names:
             parts = name.split('.')
             try:
@@ -887,13 +1009,17 @@ builtins. Remember that you should avoid to define new builtins when possible.'
             self._check_module_attrs(node, module, parts[1:])
 
     @check_messages('no-name-in-module')
-    def visit_from(self, node):
+    def visit_importfrom(self, node):
         """check modules attribute accesses"""
+        if node_ignores_exception(node, ImportError):
+            # No need to verify this, since ImportError is already
+            # handled by the client code.
+            return
+
         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
+            module = node.do_import_module(name_parts[0])
+        except Exception:
             return
         module = self._check_module_attrs(node, module, name_parts[1:])
         if not module:
@@ -913,7 +1039,8 @@ builtins. Remember that you should avoid to define new builtins when possible.'
 
         targets = node.targets[0].itered()
         try:
-            for infered in node.value.infer():
+            infered = safe_infer(node.value)
+            if infered is not None:
                 self._check_unpacking(infered, node, targets)
         except astroid.InferenceError:
             return
@@ -922,6 +1049,10 @@ builtins. Remember that you should avoid to define new builtins when possible.'
         """ Check for unbalanced tuple unpacking
         and unpacking non sequences.
         """
+        if is_inside_abstract_class(node):
+            return
+        if is_comprehension(node):
+            return
         if infered is astroid.YES:
             return
         if (isinstance(infered.parent, astroid.Arguments) and
@@ -942,19 +1073,10 @@ builtins. Remember that you should avoid to define new builtins when possible.'
                                        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:
+        else:
+            if not is_iterable(infered):
                 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):
@@ -1017,7 +1139,7 @@ class VariablesChecker3k(VariablesChecker):
         module_imports = self._to_consume[0][1]
         consumed = {}
 
-        for klass in node.nodes_of_class(astroid.Class):
+        for klass in node.nodes_of_class(astroid.ClassDef):
             found = metaclass = name = None
             if not klass._metaclass:
                 # Skip if this class doesn't use
@@ -1043,7 +1165,7 @@ class VariablesChecker3k(VariablesChecker):
                 name = None
                 if isinstance(klass._metaclass, astroid.Name):
                     name = klass._metaclass.name
-                elif isinstance(klass._metaclass, astroid.Getattr):
+                elif isinstance(klass._metaclass, astroid.Attribute):
                     name = klass._metaclass.as_string()
 
                 if name is not None: