libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/logilab/astroid/builder.py

@@ -22,23 +22,26 @@ at the same time.
 """
 from __future__ import with_statement
 
-__docformat__ = "restructuredtext en"
-
+import _ast
+import os
 import sys
-from os.path import splitext, basename, exists, abspath
+import textwrap
+
+from astroid import bases
+from astroid import exceptions
+from astroid import manager
+from astroid import modutils
+from astroid import raw_building
+from astroid import rebuilder
+from astroid import util
 
-from astroid.exceptions import AstroidBuildingException, InferenceError
-from astroid.raw_building import InspectBuilder
-from astroid.rebuilder import TreeRebuilder
-from astroid.manager import AstroidManager
-from astroid.bases import YES, Instance
-from astroid.modutils import modpath_from_file
 
-from _ast import PyCF_ONLY_AST
-def parse(string):
-    return compile(string, "<string>", 'exec', PyCF_ONLY_AST)
+def _parse(string):
+    return compile(string, "<string>", 'exec', _ast.PyCF_ONLY_AST)
+
 
 if sys.version_info >= (3, 0):
+    # pylint: disable=no-name-in-module; We don't understand flows yet.
     from tokenize import detect_encoding
 
     def open_source_file(filename):
@@ -47,10 +50,10 @@ if sys.version_info >= (3, 0):
         stream = open(filename, 'r', newline=None, encoding=encoding)
         try:
             data = stream.read()
-        except UnicodeError: # wrong encodingg
+        except UnicodeError:  # wrong encoding
             # detect_encoding returns utf-8 if no encoding specified
             msg = 'Wrong (%s) or no encoding specified' % encoding
-            raise AstroidBuildingException(msg)
+            raise exceptions.AstroidBuildingException(msg)
         return stream, encoding, data
 
 else:
@@ -59,8 +62,7 @@ else:
     _ENCODING_RGX = re.compile(r"\s*#+.*coding[:=]\s*([-\w.]+)")
 
     def _guess_encoding(string):
-        """get encoding from a python file as string or return None if not found
-        """
+        """get encoding from a python file as string or return None if not found"""
         # check for UTF-8 byte-order mark
         if string.startswith('\xef\xbb\xbf'):
             return 'UTF-8'
@@ -77,95 +79,101 @@ else:
         encoding = _guess_encoding(data)
         return stream, encoding, data
 
-# ast NG builder ##############################################################
 
-MANAGER = AstroidManager()
+MANAGER = manager.AstroidManager()
 
-class AstroidBuilder(InspectBuilder):
-    """provide astroid building methods"""
 
-    def __init__(self, manager=None):
-        InspectBuilder.__init__(self)
+class AstroidBuilder(raw_building.InspectBuilder):
+    """Class for building an astroid tree from source code or from a live module.
+
+    The param *manager* specifies the manager class which should be used.
+    If no manager is given, then the default one will be used. The
+    param *apply_transforms* determines if the transforms should be
+    applied after the tree was built from source or from a live object,
+    by default being True.
+    """
+
+    def __init__(self, manager=None, apply_transforms=True):
+        super(AstroidBuilder, self).__init__()
         self._manager = manager or MANAGER
+        self._apply_transforms = apply_transforms
 
     def module_build(self, module, modname=None):
-        """build an astroid from a living module instance
-        """
+        """Build an astroid from a living module instance."""
         node = None
         path = getattr(module, '__file__', None)
         if path is not None:
-            path_, ext = splitext(module.__file__)
-            if ext in ('.py', '.pyc', '.pyo') and exists(path_ + '.py'):
+            path_, ext = os.path.splitext(modutils._path_from_filename(path))
+            if ext in ('.py', '.pyc', '.pyo') and os.path.exists(path_ + '.py'):
                 node = self.file_build(path_ + '.py', modname)
         if node is None:
             # this is a built-in module
             # get a partial representation by introspection
             node = self.inspect_build(module, modname=modname, path=path)
-            # we have to handle transformation by ourselves since the rebuilder
-            # isn't called for builtin nodes
-            #
-            # XXX it's then only called for Module nodes, not for underlying
-            # nodes
-            node = self._manager.transform(node)
+            if self._apply_transforms:
+                # We have to handle transformation by ourselves since the
+                # rebuilder isn't called for builtin nodes
+                node = self._manager.visit_transforms(node)
         return node
 
     def file_build(self, path, modname=None):
-        """build astroid from a source code file (i.e. from an ast)
+        """Build astroid from a source code file (i.e. from an ast)
 
-        path is expected to be a python source file
+        *path* is expected to be a python source file
         """
         try:
             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 as exc: # py3k encoding specification error
-            raise AstroidBuildingException(exc)
-        except LookupError as exc: # unknown encoding
-            raise AstroidBuildingException(exc)
+            raise exceptions.AstroidBuildingException(msg)
+        except SyntaxError as exc:  # py3k encoding specification error
+            raise exceptions.AstroidBuildingException(exc)
+        except LookupError as exc:  # unknown encoding
+            raise exceptions.AstroidBuildingException(exc)
         with stream:
             # get module name if necessary
             if modname is None:
                 try:
-                    modname = '.'.join(modpath_from_file(path))
+                    modname = '.'.join(modutils.modpath_from_file(path))
                 except ImportError:
-                    modname = splitext(basename(path))[0]
+                    modname = os.path.splitext(os.path.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"""
+        """Build astroid from source code string."""
         module = self._data_build(data, modname, path)
-        module.file_bytes = data.encode('utf-8')
+        module.source_code = 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
-        """
+        """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:
+        for from_node in module._import_from_nodes:
             if from_node.modname == '__future__':
                 for symbol, _ in from_node.names:
-                    module.future_imports.add(symbol)
+                    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)
+
+        # Visit the transforms
+        if self._apply_transforms:
+            module = self._manager.visit_transforms(module)
         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
+        """Build tree node from data and add some informations"""
         try:
-            node = parse(data + '\n')
-        except TypeError as exc:
-            raise AstroidBuildingException(exc)
+            node = _parse(data + '\n')
+        except (TypeError, ValueError, SyntaxError) as exc:
+            raise exceptions.AstroidBuildingException(exc)
         if path is not None:
-            node_file = abspath(path)
+            node_file = os.path.abspath(path)
         else:
             node_file = '<?>'
         if modname.endswith('.__init__'):
@@ -173,68 +181,83 @@ class AstroidBuilder(InspectBuilder):
             package = True
         else:
             package = path and path.find('__init__.py') > -1 or False
-        rebuilder = TreeRebuilder(self._manager)
-        module = rebuilder.visit_module(node, modname, node_file, package)
-        module._from_nodes = rebuilder._from_nodes
-        module._delayed_assattr = rebuilder._delayed_assattr
+        builder = rebuilder.TreeRebuilder(self._manager)
+        module = builder.visit_module(node, modname, node_file, package)
+        module._import_from_nodes = builder._import_from_nodes
+        module._delayed_assattr = builder._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
-        """
+        """Store imported names to the locals
 
+        Resort the locals if coming from a delayed node
+        """
         _key_func = lambda node: node.fromlineno
         def sort_locals(my_list):
             my_list.sort(key=_key_func)
+
         for (name, asname) in node.names:
             if name == '*':
                 try:
                     imported = node.do_import_module()
-                except InferenceError:
+                except exceptions.InferenceError:
                     continue
-                for name in imported.wildcard_import_names():
+                for name in imported._public_names():
                     node.parent.set_local(name, node)
-                    sort_locals(node.parent.scope().locals[name])
+                    sort_locals(node.parent.scope()._locals[name])
             else:
                 node.parent.set_local(asname or name, node)
-                sort_locals(node.parent.scope().locals[asname or name])
+                sort_locals(node.parent.scope()._locals[asname or name])
 
     def delayed_assattr(self, node):
-        """visit a AssAttr node -> add name to locals, handle members
-        definition
+        """Visit a AssAttr node
+
+        This adds name to locals and handle members definition.
         """
         try:
             frame = node.frame()
-            for infered in node.expr.infer():
-                if infered is YES:
+            for inferred in node.expr.infer():
+                if inferred is util.YES:
                     continue
                 try:
-                    if infered.__class__ is Instance:
-                        infered = infered._proxied
-                        iattrs = infered.instance_attrs
-                    elif isinstance(infered, Instance):
+                    if inferred.__class__ is bases.Instance:
+                        inferred = inferred._proxied
+                        iattrs = inferred._instance_attrs
+                    elif isinstance(inferred, bases.Instance):
                         # Const, Tuple, ... we may be wrong, may be not, but
                         # anyway we don't want to pollute builtin's namespace
                         continue
-                    elif infered.is_function:
-                        iattrs = infered.instance_attrs
+                    elif inferred.is_function:
+                        iattrs = inferred._instance_attrs
                     else:
-                        iattrs = infered.locals
+                        iattrs = inferred._locals
                 except AttributeError:
                     # XXX log error
-                    #import traceback
-                    #traceback.print_exc()
                     continue
                 values = iattrs.setdefault(node.attrname, [])
                 if node in values:
                     continue
                 # get assign in __init__ first XXX useful ?
-                if frame.name == '__init__' and values and not \
-                       values[0].frame().name == '__init__':
+                if (frame.name == '__init__' and values and
+                        not values[0].frame().name == '__init__'):
                     values.insert(0, node)
                 else:
                     values.append(node)
-        except InferenceError:
+        except exceptions.InferenceError:
             pass
 
+
+def parse(code, module_name='', path=None, apply_transforms=True):
+    """Parses a source string in order to obtain an astroid AST from it
+
+    :param str code: The code for the module.
+    :param str module_name: The name for the module, if any
+    :param str path: The path for the module
+    :param bool apply_transforms:
+        Apply the transforms for the give code. Use it if you
+        don't want the default transforms to be applied.
+    """
+    code = textwrap.dedent(code)
+    builder = AstroidBuilder(manager=MANAGER,
+                             apply_transforms=apply_transforms)
+    return builder.string_build(code, modname=module_name, path=path)

data/vendor/depot_tools/third_party/logilab/astroid/context.py

@@ -0,0 +1,81 @@
+# copyright 2003-2015 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/>.
+
+"""Various context related utilities, including inference and call contexts."""
+
+import contextlib
+
+
+class InferenceContext(object):
+    __slots__ = ('path', 'lookupname', 'callcontext', 'boundnode', 'inferred')
+
+    def __init__(self, path=None, inferred=None):
+        self.path = path or set()
+        self.lookupname = None
+        self.callcontext = None
+        self.boundnode = None
+        self.inferred = inferred or {}
+
+    def push(self, node):
+        name = self.lookupname
+        if (node, name) in self.path:
+            raise StopIteration()
+        self.path.add((node, name))
+
+    def clone(self):
+        # XXX copy lookupname/callcontext ?
+        clone = InferenceContext(self.path, inferred=self.inferred)
+        clone.callcontext = self.callcontext
+        clone.boundnode = self.boundnode
+        return clone
+
+    def cache_generator(self, key, generator):
+        results = []
+        for result in generator:
+            results.append(result)
+            yield result
+
+        self.inferred[key] = tuple(results)
+        return
+
+    @contextlib.contextmanager
+    def restore_path(self):
+        path = set(self.path)
+        yield
+        self.path = path
+
+
+class CallContext(object):
+    """Holds information for a call site."""
+
+    __slots__ = ('args', 'keywords')
+
+    def __init__(self, args, keywords=None):
+        self.args = args
+        if keywords:
+            keywords = [(arg.arg, arg.value) for arg in keywords]
+        else:
+            keywords = []
+        self.keywords = keywords
+
+
+def copy_context(context):
+    if context is not None:
+        return context.clone()
+    else:
+        return InferenceContext()

data/vendor/depot_tools/third_party/logilab/astroid/decorators.py

@@ -0,0 +1,75 @@
+# 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/>.
+#
+# The code in this file was originally part of logilab-common, licensed under
+# the same license.
+
+""" A few useful function/method decorators."""
+
+import wrapt
+
+
+@wrapt.decorator
+def cached(func, instance, args, kwargs):
+    """Simple decorator to cache result of method calls without args."""
+    cache = getattr(instance, '__cache', None)
+    if cache is None:
+        instance.__cache = cache = {}
+    try:
+        return cache[func]
+    except KeyError:
+        cache[func] = result = func(*args, **kwargs)
+        return result
+
+
+class cachedproperty(object):
+    """ Provides a cached property equivalent to the stacking of
+    @cached and @property, but more efficient.
+
+    After first usage, the <property_name> becomes part of the object's
+    __dict__. Doing:
+
+      del obj.<property_name> empties the cache.
+
+    Idea taken from the pyramid_ framework and the mercurial_ project.
+
+    .. _pyramid: http://pypi.python.org/pypi/pyramid
+    .. _mercurial: http://pypi.python.org/pypi/Mercurial
+    """
+    __slots__ = ('wrapped',)
+
+    def __init__(self, wrapped):
+        try:
+            wrapped.__name__
+        except AttributeError:
+            raise TypeError('%s must have a __name__ attribute' %
+                            wrapped)
+        self.wrapped = wrapped
+
+    @property
+    def __doc__(self):
+        doc = getattr(self.wrapped, '__doc__', None)
+        return ('<wrapped by the cachedproperty decorator>%s'
+                % ('\n%s' % doc if doc else ''))
+
+    def __get__(self, inst, objtype=None):
+        if inst is None:
+            return self
+        val = self.wrapped(inst)
+        setattr(inst, self.wrapped.__name__, val)
+        return val