pylint: upgrade to 1.4.0

third_party/logilab/astroid/node_classes.py

 # copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
 #
 # This file is part of astroid.
 #
 # astroid is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
 # Free Software Foundation, either version 2.1 of the License, or (at your
 # option) any later version.
 #
 # astroid 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 Lesser General Public License
 # for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License along
 # with astroid. If not, see <http://www.gnu.org/licenses/>.
 """Module for some node classes. More nodes in scoped_nodes.py
 """
 
 import sys
 
+import six
+from logilab.common.decorators import cachedproperty
+
 from astroid.exceptions import NoDefault
 from astroid.bases import (NodeNG, Statement, Instance, InferenceContext,
                            _infer_stmts, YES, BUILTINS)
 from astroid.mixins import (BlockRangeMixIn, AssignTypeMixin,
                             ParentAssignTypeMixin, FromImportMixIn)
 
 PY3K = sys.version_info >= (3, 0)
 
 
 def unpack_infer(stmt, context=None):
     """recursively generate nodes inferred by the given statement.
     If the inferred value is a list or a tuple, recurse on the elements
     """
     if isinstance(stmt, (List, Tuple)):
         for elt in stmt.elts:
             for infered_elt in unpack_infer(elt, context):
                 yield infered_elt
         return
     # if infered is a final node, return it and stop
-    infered = stmt.infer(context).next()
+    infered = next(stmt.infer(context))
     if infered is stmt:
         yield infered
         return
     # else, infer recursivly, except YES object that should be returned as is
     for infered in stmt.infer(context):
         if infered is YES:
             yield infered
         else:
             for inf_inf in unpack_infer(infered, context):
                 yield inf_inf
@@ skipping 67 matching lines @@
         """
         return self.scope().scope_lookup(self, name)
 
     def ilookup(self, name):
         """infered lookup
 
         return an iterator on infered values of the statements returned by
         the lookup method
         """
         frame, stmts = self.lookup(name)
-        context = InferenceContext()
-        return _infer_stmts(stmts, context, frame)
+        return _infer_stmts(stmts, None, frame)
 
     def _filter_stmts(self, stmts, frame, offset):
         """filter statements to remove ignorable statements.
 
         If self is not a frame itself and the name is found in the inner
         frame locals, statements will be filtered to remove ignorable
         statements according to self's location
         """
         # if offset == -1, my actual frame is not the inner frame but its parent
         #
         # class A(B): pass
         #
         # we need this to resolve B correctly
         if offset == -1:
             myframe = self.frame().parent.frame()
         else:
             myframe = self.frame()
+            # If the frame of this node is the same as the statement
+            # of this node, then the node is part of a class or
+            # a function definition and the frame of this node should be the
+            # the upper frame, not the frame of the definition.
+            # For more information why this is important,
+            # see Pylint issue #295.
+            # For example, for 'b', the statement is the same
+            # as the frame / scope:
+            #
+            # def test(b=1):
+            #     ...
+
+            if self.statement() is myframe and myframe.parent:
+                myframe = myframe.parent.frame()
         if not myframe is frame or self is frame:
             return stmts
         mystmt = self.statement()
         # line filtering if we are in the same frame
         #
         # take care node may be missing lineno information (this is the case for
         # nodes inserted for living objects)
         if myframe is frame and mystmt.fromlineno is not None:
             assert mystmt.fromlineno is not None, mystmt
             mylineno = mystmt.fromlineno + offset
@@ skipping 123 matching lines @@
 
     def __init__(self, vararg=None, kwarg=None):
         self.vararg = vararg
         self.kwarg = kwarg
 
     def _infer_name(self, frame, name):
         if self.parent is frame:
             return name
         return None
 
+    @cachedproperty
+    def fromlineno(self):
+        lineno = super(Arguments, self).fromlineno
+        return max(lineno, self.parent.fromlineno)
+
     def format_args(self):
         """return arguments formatted as string"""
         result = []
         if self.args:
             result.append(_format_args(self.args, self.defaults))
         if self.vararg:
             result.append('*%s' % self.vararg)
         if self.kwarg:
             result.append('**%s' % self.kwarg)
         if self.kwonlyargs:
@@ skipping 166 matching lines @@
         return stmts, False
 
 
 class Const(NodeNG, Instance):
     """represent a constant node like num, str, bool, None, bytes"""
 
     def __init__(self, value=None):
         self.value = value
 
     def getitem(self, index, context=None):
-        if isinstance(self.value, basestring):
+        if isinstance(self.value, six.string_types):
             return Const(self.value[index])
         raise TypeError('%r (value=%s)' % (self, self.value))
 
     def has_dynamic_getattr(self):
         return False
 
     def itered(self):
-        if isinstance(self.value, basestring):
+        if isinstance(self.value, six.string_types):
             return self.value
         raise TypeError()
 
     def pytype(self):
         return self._proxied.qname()
 
 
 class Continue(Statement):
     """class representing a Continue node"""
 
@@ skipping 24 matching lines @@
 
 class Dict(NodeNG, Instance):
     """class representing a Dict node"""
     _astroid_fields = ('items',)
 
     def __init__(self, items=None):
         if items is None:
             self.items = []
         else:
             self.items = [(const_factory(k), const_factory(v))
-                          for k, v in items.iteritems()]
+                          for k, v in items.items()]
 
     def pytype(self):
         return '%s.dict' % BUILTINS
 
     def get_children(self):
         """get children of a Dict node"""
         # overrides get_children
         for key, value in self.items:
             yield key
             yield value
@@ skipping 34 matching lines @@
     """class representing an EmptyNode node"""
 
 
 class ExceptHandler(Statement, AssignTypeMixin):
     """class representing an ExceptHandler node"""
     _astroid_fields = ('type', 'name', 'body',)
     type = None
     name = None
     body = None
 
-    def _blockstart_toline(self):
+    @cachedproperty
+    def blockstart_tolineno(self):
         if self.name:
             return self.name.tolineno
         elif self.type:
             return self.type.tolineno
         else:
             return self.lineno
 
-    def set_line_info(self, lastchild):
-        self.fromlineno = self.lineno
-        self.tolineno = lastchild.tolineno
-        self.blockstart_tolineno = self._blockstart_toline()
-
     def catch(self, exceptions):
         if self.type is None or exceptions is None:
             return True
         for node in self.type.nodes_of_class(Name):
             if node.name in exceptions:
                 return True
 
 
 class Exec(Statement):
     """class representing an Exec node"""
@@ skipping 10 matching lines @@
 
 class For(BlockRangeMixIn, AssignTypeMixin, Statement):
     """class representing a For node"""
     _astroid_fields = ('target', 'iter', 'body', 'orelse',)
     target = None
     iter = None
     body = None
     orelse = None
 
     optional_assign = True
-    def _blockstart_toline(self):
+    @cachedproperty
+    def blockstart_tolineno(self):
         return self.iter.tolineno
 
 
 class From(FromImportMixIn, Statement):
     """class representing a From node"""
 
     def __init__(self, fromname, names, level=0):
         self.modname = fromname
         self.names = names
         self.level = level
@@ skipping 14 matching lines @@
         return name
 
 
 class If(BlockRangeMixIn, Statement):
     """class representing an If node"""
     _astroid_fields = ('test', 'body', 'orelse')
     test = None
     body = None
     orelse = None
 
-    def _blockstart_toline(self):
+    @cachedproperty
+    def blockstart_tolineno(self):
         return self.test.tolineno
 
     def block_range(self, lineno):
         """handle block line numbers range for if statements"""
         if lineno == self.body[0].fromlineno:
             return lineno, lineno
         if lineno <= self.body[-1].tolineno:
             return lineno, self.body[-1].tolineno
         return self._elsed_block_range(lineno, self.orelse,
                                        self.body[0].fromlineno - 1)
@@ skipping 130 matching lines @@
 class TryExcept(BlockRangeMixIn, Statement):
     """class representing a TryExcept node"""
     _astroid_fields = ('body', 'handlers', 'orelse',)
     body = None
     handlers = None
     orelse = None
 
     def _infer_name(self, frame, name):
         return name
 
-    def _blockstart_toline(self):
-        return self.lineno
-
     def block_range(self, lineno):
         """handle block line numbers range for try/except statements"""
         last = None
         for exhandler in self.handlers:
             if exhandler.type and lineno == exhandler.type.fromlineno:
                 return lineno, lineno
             if exhandler.body[0].fromlineno <= lineno <= exhandler.body[-1].tolineno:
                 return lineno, exhandler.body[-1].tolineno
             if last is None:
                 last = exhandler.body[0].fromlineno - 1
         return self._elsed_block_range(lineno, self.orelse, last)
 
 
 class TryFinally(BlockRangeMixIn, Statement):
     """class representing a TryFinally node"""
     _astroid_fields = ('body', 'finalbody',)
     body = None
     finalbody = None
 
-    def _blockstart_toline(self):
-        return self.lineno
-
     def block_range(self, lineno):
         """handle block line numbers range for try/finally statements"""
         child = self.body[0]
         # py2.5 try: except: finally:
         if (isinstance(child, TryExcept) and child.fromlineno == self.fromlineno
                 and lineno > self.fromlineno and lineno <= child.tolineno):
             return child.block_range(lineno)
         return self._elsed_block_range(lineno, self.finalbody)
 
 
@@ skipping 23 matching lines @@
     operand = None
 
 
 class While(BlockRangeMixIn, Statement):
     """class representing a While node"""
     _astroid_fields = ('test', 'body', 'orelse',)
     test = None
     body = None
     orelse = None
 
-    def _blockstart_toline(self):
+    @cachedproperty
+    def blockstart_tolineno(self):
         return self.test.tolineno
 
     def block_range(self, lineno):
         """handle block line numbers range for for and while statements"""
         return self. _elsed_block_range(lineno, self.orelse)
 
 
 class With(BlockRangeMixIn, AssignTypeMixin, Statement):
     """class representing a With node"""
     _astroid_fields = ('items', 'body')
     items = None
     body = None
 
-    def _blockstart_toline(self):
+    @cachedproperty
+    def blockstart_tolineno(self):
         return self.items[-1][0].tolineno
 
     def get_children(self):
         for expr, var in self.items:
             yield expr
             if var:
                 yield var
         for elt in self.body:
             yield elt
 
@@ skipping 33 matching lines @@
     # we should rather recall the builder on this value than returning an empty
     # node (another option being that const_factory shouldn't be called with something
     # not in CONST_CLS)
     assert not isinstance(value, NodeNG)
     try:
         return CONST_CLS[value.__class__](value)
     except (KeyError, AttributeError):
         node = EmptyNode()
         node.object = value
         return node