pylint: upgrade to 1.4.0

third_party/logilab/astroid/builder.py

 # copyright 2003-2014 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.
 #
@@ skipping 26 matching lines @@
 from _ast import PyCF_ONLY_AST
 def parse(string):
     return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
 
 if sys.version_info >= (3, 0):
     from tokenize import detect_encoding
 
     def open_source_file(filename):
         with open(filename, 'rb') as byte_stream:
             encoding = detect_encoding(byte_stream.readline)[0]
-        stream = open(filename, 'rU', encoding=encoding)
+        stream = open(filename, 'r', newline=None, encoding=encoding)
         try:
             data = stream.read()
         except UnicodeError: # wrong encodingg
             # detect_encoding returns utf-8 if no encoding specified
             msg = 'Wrong (%s) or no encoding specified' % encoding
             raise AstroidBuildingException(msg)
         return stream, encoding, data
 
 else:
     import re
@@ skipping 50 matching lines @@
             # nodes
             node = self._manager.transform(node)
         return node
 
     def file_build(self, path, modname=None):
         """build astroid from a source code file (i.e. from an ast)
 
         path is expected to be a python source file
         """
         try:
-            _, encoding, data = open_source_file(path)
-        except IOError, exc:
+            stream, encoding, data = open_source_file(path)
+        except IOError as exc:
             msg = 'Unable to load file %r (%s)' % (path, exc)
             raise AstroidBuildingException(msg)
-        except SyntaxError, exc: # py3k encoding specification error
+        except SyntaxError as exc: # py3k encoding specification error
             raise AstroidBuildingException(exc)
-        except LookupError, exc: # unknown encoding
+        except LookupError as exc: # unknown encoding
             raise AstroidBuildingException(exc)
-        # get module name if necessary
-        if modname is None:
-            try:
-                modname = '.'.join(modpath_from_file(path))
-            except ImportError:
-                modname = splitext(basename(path))[0]
-        # build astroid representation
-        module = self._data_build(data, modname, path)
-        return self._post_build(module, encoding)
+        with stream:
+            # get module name if necessary
+            if modname is None:
+                try:
+                    modname = '.'.join(modpath_from_file(path))
+                except ImportError:
+                    modname = splitext(basename(path))[0]
+            # build astroid representation
+            module = self._data_build(data, modname, path)
+            return self._post_build(module, encoding)
 
     def string_build(self, data, modname='', path=None):
         """build astroid from source code string and return rebuilded astroid"""
         module = self._data_build(data, modname, path)
         module.file_bytes = data.encode('utf-8')
         return self._post_build(module, 'utf-8')
 
     def _post_build(self, module, encoding):
         """handles encoding and delayed nodes
         after a module has been built
         """
         module.file_encoding = encoding
         self._manager.cache_module(module)
         # post tree building steps after we stored the module in the cache:
         for from_node in module._from_nodes:
             if from_node.modname == '__future__':
                 for symbol, _ in from_node.names:
                     module.future_imports.add(symbol)
             self.add_from_names_to_locals(from_node)
         # handle delayed assattr nodes
         for delayed in module._delayed_assattr:
             self.delayed_assattr(delayed)
         return module
 
     def _data_build(self, data, modname, path):
         """build tree node from data and add some informations"""
         # this method could be wrapped with a pickle/cache function
-        node = parse(data + '\n')
+        try:
+            node = parse(data + '\n')
+        except TypeError as exc:
+            raise AstroidBuildingException(exc)
         if path is not None:
             node_file = abspath(path)
         else:
             node_file = '<?>'
         if modname.endswith('.__init__'):
             modname = modname[:-9]
             package = True
         else:
             package = path and path.find('__init__.py') > -1 or False
         rebuilder = TreeRebuilder(self._manager)
-        module = rebuilder.visit_module(node, modname, package)
-        module.file = module.path = node_file
+        module = rebuilder.visit_module(node, modname, node_file, package)
         module._from_nodes = rebuilder._from_nodes
         module._delayed_assattr = rebuilder._delayed_assattr
         return module
 
     def add_from_names_to_locals(self, node):
         """store imported names to the locals;
         resort the locals if coming from a delayed node
         """
 
         _key_func = lambda node: node.fromlineno
@@ skipping 43 matching lines @@
                     continue
                 # get assign in __init__ first XXX useful ?
                 if frame.name == '__init__' and values and not \
                        values[0].frame().name == '__init__':
                     values.insert(0, node)
                 else:
                     values.append(node)
         except InferenceError:
             pass