pylint: upgrade to 1.4.0

third_party/pylint/checkers/utils.py

 # pylint: disable=W0611
 #
 # Copyright (c) 2003-2013 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.
 #
@@ skipping 12 matching lines @@
 import string
 
 import astroid
 from astroid import scoped_nodes
 from logilab.common.compat import builtins
 
 BUILTINS_NAME = builtins.__name__
 COMP_NODE_TYPES = astroid.ListComp, astroid.SetComp, astroid.DictComp, astroid.GenExpr
 PY3K = sys.version_info[0] == 3
 
+if not PY3K:
+    EXCEPTIONS_MODULE = "exceptions"
+else:
+    EXCEPTIONS_MODULE = "builtins"
+
 
 class NoSuchArgumentError(Exception):
     pass
 
 def is_inside_except(node):
     """Returns true if node is inside the name of an except handler."""
     current = node
     while current and not isinstance(current.parent, astroid.ExceptHandler):
         current = current.parent
 
@@ skipping 32 matching lines @@
     return (False, None)
 
 
 def safe_infer(node):
     """return the inferred value for the given node.
     Return None if inference failed or if there is some ambiguity (more than
     one node has been inferred)
     """
     try:
         inferit = node.infer()
-        value = inferit.next()
+        value = next(inferit)
     except astroid.InferenceError:
         return
     try:
-        inferit.next()
+        next(inferit)
         return # None if there is ambiguity on the inferred node
     except astroid.InferenceError:
         return # there is some kind of ambiguity
     except StopIteration:
         return value
 
 def is_super(node):
     """return True if the node is referencing the "super" builtin function
     """
     if getattr(node, 'name', None) == 'super' and \
@@ skipping 45 matching lines @@
     while _node:
         if isinstance(_node, COMP_NODE_TYPES):
             for ass_node in _node.nodes_of_class(astroid.AssName):
                 if ass_node.name == varname:
                     return True
         elif isinstance(_node, astroid.For):
             for ass_node in _node.target.nodes_of_class(astroid.AssName):
                 if ass_node.name == varname:
                     return True
         elif isinstance(_node, astroid.With):
-            for expr, vars in _node.items:
+            for expr, ids in _node.items:
                 if expr.parent_of(var_node):
                     break
-                if (vars and
-                        isinstance(vars, astroid.AssName) and
-                        vars.name == varname):
+                if (ids and
+                        isinstance(ids, astroid.AssName) and
+                        ids.name == varname):
                     return True
         elif isinstance(_node, (astroid.Lambda, astroid.Function)):
             if _node.args.is_argument(varname):
                 return True
             if getattr(_node, 'name', None) == varname:
                 return True
             break
         elif isinstance(_node, astroid.ExceptHandler):
             if isinstance(_node.name, astroid.AssName):
                 ass_node = _node.name
@@ skipping 234 matching lines @@
     :returns: The node representing the argument, None if the argument is not found.
     :raises ValueError: if both position and keyword are None.
     :raises NoSuchArgumentError: if no argument at the provided position or with
     the provided keyword.
     """
     if position is None and keyword is None:
         raise ValueError('Must specify at least one of: position or keyword.')
     try:
         if position is not None and not isinstance(callfunc_node.args[position], astroid.Keyword):
             return callfunc_node.args[position]
-    except IndexError, error:
+    except IndexError as error:
         raise NoSuchArgumentError(error)
     if keyword:
         for arg in callfunc_node.args:
             if isinstance(arg, astroid.Keyword) and arg.arg == keyword:
                 return arg.value
     raise NoSuchArgumentError
+
+def inherit_from_std_ex(node):
+    """
+    Return true if the given class node is subclass of
+    exceptions.Exception.
+    """
+    if node.name in ('Exception', 'BaseException') \
+            and node.root().name == EXCEPTIONS_MODULE:
+        return True
+    return any(inherit_from_std_ex(parent)
+               for parent in node.ancestors(recurs=False))
+
+def is_import_error(handler):
+    """
+    Check if the given exception handler catches
+    ImportError.
+
+    :param handler: A node, representing an ExceptHandler node.
+    :returns: True if the handler catches ImportError, False otherwise.
+    """
+    names = None
+    if isinstance(handler.type, astroid.Tuple):
+        names = [name for name in handler.type.elts
+                 if isinstance(name, astroid.Name)]
+    elif isinstance(handler.type, astroid.Name):
+        names = [handler.type]
+    else:
+        # Don't try to infer that.
+        return
+    for name in names:
+        try:
+            for infered in name.infer():
+                if (isinstance(infered, astroid.Class) and
+                        inherit_from_std_ex(infered) and
+                        infered.name == 'ImportError'):
+                    return True
+        except astroid.InferenceError:
+            continue
+
+def has_known_bases(klass):
+    """Returns true if all base classes of a class could be inferred."""
+    try:
+        return klass._all_bases_known
+    except AttributeError:
+        pass
+    for base in klass.bases:
+        result = safe_infer(base)
+        # TODO: check for A->B->A->B pattern in class structure too?
+        if (not isinstance(result, astroid.Class) or
+                result is klass or
+                not has_known_bases(result)):
+            klass._all_bases_known = False
+            return False
+    klass._all_bases_known = True
+    return True
+
+def decorated_with_property(node):
+    """ Detect if the given function node is decorated with a property. """
+    if not node.decorators:
+        return False
+    for decorator in node.decorators.nodes:
+        if not isinstance(decorator, astroid.Name):
+            continue
+        try:
+            for infered in decorator.infer():
+                if isinstance(infered, astroid.Class):
+                    if (infered.root().name == BUILTINS_NAME and
+                            infered.name == 'property'):
+                        return True
+                    for ancestor in infered.ancestors():
+                        if (ancestor.name == 'property' and
+                                ancestor.root().name == BUILTINS_NAME):
+                            return True
+        except astroid.InferenceError:
+            pass