libv8 7.3.492.27.0 → 8.4.255.0

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

@@ -1,359 +0,0 @@
-# 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/>.
-"""this module contains a set of functions to handle inference on astroid trees
-"""
-
-from __future__ import print_function
-
-from astroid import bases
-from astroid import context as contextmod
-from astroid import exceptions
-from astroid import manager
-from astroid import nodes
-from astroid import protocols
-from astroid import util
-
-
-MANAGER = manager.AstroidManager()
-
-
-# .infer method ###############################################################
-
-
-def infer_end(self, context=None):
-    """inference's end for node such as Module, ClassDef, FunctionDef,
-    Const...
-
-    """
-    yield self
-nodes.Module._infer = infer_end
-nodes.ClassDef._infer = infer_end
-nodes.FunctionDef._infer = infer_end
-nodes.Lambda._infer = infer_end
-nodes.Const._infer = infer_end
-nodes.List._infer = infer_end
-nodes.Tuple._infer = infer_end
-nodes.Dict._infer = infer_end
-nodes.Set._infer = infer_end
-
-def _higher_function_scope(node):
-    """ Search for the first function which encloses the given
-    scope. This can be used for looking up in that function's
-    scope, in case looking up in a lower scope for a particular
-    name fails.
-
-    :param node: A scope node.
-    :returns:
-        ``None``, if no parent function scope was found,
-        otherwise an instance of :class:`astroid.scoped_nodes.Function`,
-        which encloses the given node.
-    """
-    current = node
-    while current.parent and not isinstance(current.parent, nodes.FunctionDef):
-        current = current.parent
-    if current and current.parent:
-        return current.parent
-
-def infer_name(self, context=None):
-    """infer a Name: use name lookup rules"""
-    frame, stmts = self.lookup(self.name)
-    if not stmts:
-        # Try to see if the name is enclosed in a nested function
-        # and use the higher (first function) scope for searching.
-        # TODO: should this be promoted to other nodes as well?
-        parent_function = _higher_function_scope(self.scope())
-        if parent_function:
-            _, stmts = parent_function.lookup(self.name)
-
-        if not stmts:
-            raise exceptions.UnresolvableName(self.name)
-    context = context.clone()
-    context.lookupname = self.name
-    return bases._infer_stmts(stmts, context, frame)
-nodes.Name._infer = bases.path_wrapper(infer_name)
-nodes.AssignName.infer_lhs = infer_name # won't work with a path wrapper
-
-
-@bases.path_wrapper
-@bases.raise_if_nothing_inferred
-def infer_call(self, context=None):
-    """infer a Call node by trying to guess what the function returns"""
-    callcontext = context.clone()
-    callcontext.callcontext = contextmod.CallContext(args=self.args,
-                                                     keywords=self.keywords)
-    callcontext.boundnode = None
-    for callee in self.func.infer(context):
-        if callee is util.YES:
-            yield callee
-            continue
-        try:
-            if hasattr(callee, 'infer_call_result'):
-                for inferred in callee.infer_call_result(self, callcontext):
-                    yield inferred
-        except exceptions.InferenceError:
-            ## XXX log error ?
-            continue
-nodes.Call._infer = infer_call
-
-
-@bases.path_wrapper
-def infer_import(self, context=None, asname=True):
-    """infer an Import node: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise exceptions.InferenceError()
-    if asname:
-        yield self.do_import_module(self.real_name(name))
-    else:
-        yield self.do_import_module(name)
-nodes.Import._infer = infer_import
-
-
-def infer_name_module(self, name):
-    context = contextmod.InferenceContext()
-    context.lookupname = name
-    return self.infer(context, asname=False)
-nodes.Import.infer_name_module = infer_name_module
-
-
-@bases.path_wrapper
-def infer_import_from(self, context=None, asname=True):
-    """infer a ImportFrom node: return the imported module/object"""
-    name = context.lookupname
-    if name is None:
-        raise exceptions.InferenceError()
-    if asname:
-        name = self.real_name(name)
-    module = self.do_import_module()
-    try:
-        context = contextmod.copy_context(context)
-        context.lookupname = name
-        stmts = module.getattr(name, ignore_locals=module is self.root())
-        return bases._infer_stmts(stmts, context)
-    except exceptions.NotFoundError:
-        raise exceptions.InferenceError(name)
-nodes.ImportFrom._infer = infer_import_from
-
-
-@bases.raise_if_nothing_inferred
-def infer_attribute(self, context=None):
-    """infer an Attribute node by using getattr on the associated object"""
-    for owner in self.expr.infer(context):
-        if owner is util.YES:
-            yield owner
-            continue
-        try:
-            context.boundnode = owner
-            for obj in owner.igetattr(self.attrname, context):
-                yield obj
-            context.boundnode = None
-        except (exceptions.NotFoundError, exceptions.InferenceError):
-            context.boundnode = None
-        except AttributeError:
-            # XXX method / function
-            context.boundnode = None
-nodes.Attribute._infer = bases.path_wrapper(infer_attribute)
-nodes.AssignAttr.infer_lhs = infer_attribute # # won't work with a path wrapper
-
-
-@bases.path_wrapper
-def infer_global(self, context=None):
-    if context.lookupname is None:
-        raise exceptions.InferenceError()
-    try:
-        return bases._infer_stmts(self.root().getattr(context.lookupname),
-                                  context)
-    except exceptions.NotFoundError:
-        raise exceptions.InferenceError()
-nodes.Global._infer = infer_global
-
-
-@bases.raise_if_nothing_inferred
-def infer_subscript(self, context=None):
-    """Inference for subscripts
-
-    We're understanding if the index is a Const
-    or a slice, passing the result of inference
-    to the value's `getitem` method, which should
-    handle each supported index type accordingly.
-    """
-
-    value = next(self.value.infer(context))
-    if value is util.YES:
-        yield util.YES
-        return
-
-    index = next(self.slice.infer(context))
-    if index is util.YES:
-        yield util.YES
-        return
-
-    if isinstance(index, nodes.Const):
-        try:
-            assigned = value.getitem(index.value, context)
-        except AttributeError:
-            raise exceptions.InferenceError()
-        except (IndexError, TypeError):
-            yield util.YES
-            return
-
-        # Prevent inferring if the infered subscript
-        # is the same as the original subscripted object.
-        if self is assigned or assigned is util.YES:
-            yield util.YES
-            return
-        for infered in assigned.infer(context):
-            yield infered
-    else:
-        raise exceptions.InferenceError()
-nodes.Subscript._infer = bases.path_wrapper(infer_subscript)
-nodes.Subscript.infer_lhs = infer_subscript
-
-@bases.raise_if_nothing_inferred
-def infer_unaryop(self, context=None):
-    for operand in self.operand.infer(context):
-        try:
-            yield operand.infer_unary_op(self.op)
-        except TypeError:
-            continue
-        except AttributeError:
-            meth = protocols.UNARY_OP_METHOD[self.op]
-            if meth is None:
-                yield util.YES
-            else:
-                try:
-                    # XXX just suppose if the type implement meth, returned type
-                    # will be the same
-                    operand.getattr(meth)
-                    yield operand
-                except GeneratorExit:
-                    raise
-                except:
-                    yield util.YES
-nodes.UnaryOp._infer = bases.path_wrapper(infer_unaryop)
-
-def _infer_binop(binop, operand1, operand2, context, failures=None):
-    if operand1 is util.YES:
-        yield operand1
-        return
-    try:
-        for valnode in operand1.infer_binary_op(binop, operand2, context):
-            yield valnode
-    except AttributeError:
-        try:
-            # XXX just suppose if the type implement meth, returned type
-            # will be the same
-            operand1.getattr(protocols.BIN_OP_METHOD[operator])
-            yield operand1
-        except:
-            if failures is None:
-                yield util.YES
-            else:
-                failures.append(operand1)
-
-@bases.yes_if_nothing_inferred
-def infer_binop(self, context=None):
-    failures = []
-    for lhs in self.left.infer(context):
-        for val in _infer_binop(self, lhs, self.right, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.right.infer(context):
-            for val in _infer_binop(self, rhs, lhs, context):
-                yield val
-nodes.BinOp._infer = bases.path_wrapper(infer_binop)
-
-
-def infer_arguments(self, context=None):
-    name = context.lookupname
-    if name is None:
-        raise exceptions.InferenceError()
-    return protocols._arguments_infer_argname(self, name, context)
-nodes.Arguments._infer = infer_arguments
-
-
-@bases.path_wrapper
-def infer_assign(self, context=None):
-    """infer a AssignName/AssignAttr: need to inspect the RHS part of the
-    assign node
-    """
-    stmt = self.statement()
-    if isinstance(stmt, nodes.AugAssign):
-        return stmt.infer(context)
-
-    stmts = list(self.assigned_stmts(context=context))
-    return bases._infer_stmts(stmts, context)
-nodes.AssignName._infer = infer_assign
-nodes.AssignAttr._infer = infer_assign
-
-def infer_augassign(self, context=None):
-    failures = []
-    for lhs in self.target.infer_lhs(context):
-        for val in _infer_binop(self, lhs, self.value, context, failures):
-            yield val
-    for lhs in failures:
-        for rhs in self.value.infer(context):
-            for val in _infer_binop(self, rhs, lhs, context):
-                yield val
-nodes.AugAssign._infer = bases.path_wrapper(infer_augassign)
-
-
-# no infer method on DelName and DelAttr (expected InferenceError)
-
-@bases.path_wrapper
-def infer_empty_node(self, context=None):
-    if not self.has_underlying_object():
-        yield util.YES
-    else:
-        try:
-            for inferred in MANAGER.infer_ast_from_something(self.object,
-                                                             context=context):
-                yield inferred
-        except exceptions.AstroidError:
-            yield util.YES
-nodes.EmptyNode._infer = infer_empty_node
-
-
-def infer_index(self, context=None):
-    return self.value.infer(context)
-nodes.Index._infer = infer_index
-
-# TODO: move directly into bases.Instance when the dependency hell
-# will be solved.
-def instance_getitem(self, index, context=None):
-    # Rewrap index to Const for this case
-    index = nodes.Const(index)
-    if context:
-        new_context = context.clone()
-    else:
-        context = new_context = contextmod.InferenceContext()
-
-    # Create a new callcontext for providing index as an argument.
-    new_context.callcontext = contextmod.CallContext(args=[index])
-    new_context.boundnode = self
-
-    method = next(self.igetattr('__getitem__', context=context))
-    if not isinstance(method, bases.BoundMethod):
-        raise exceptions.InferenceError
-
-    try:
-        return next(method.infer_call_result(self, new_context))
-    except StopIteration:
-        raise exceptions.InferenceError
-
-bases.Instance.getitem = instance_getitem

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

@@ -1,267 +0,0 @@
-# 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/>.
-"""astroid manager: avoid multiple astroid build of a same module when
-possible by providing a class responsible to get astroid representation
-from various source and using a cache of built modules)
-"""
-from __future__ import print_function
-
-import imp
-import os
-import zipimport
-
-from astroid import exceptions
-from astroid import modutils
-from astroid import transforms
-
-
-def safe_repr(obj):
-    try:
-        return repr(obj)
-    except Exception: # pylint: disable=broad-except
-        return '???'
-
-
-class AstroidManager(object):
-    """the astroid manager, responsible to build astroid from files
-     or modules.
-
-    Use the Borg pattern.
-    """
-
-    name = 'astroid loader'
-    brain = {}
-
-    def __init__(self):
-        self.__dict__ = AstroidManager.brain
-        if not self.__dict__:
-            # NOTE: cache entries are added by the [re]builder
-            self.astroid_cache = {}
-            self._mod_file_cache = {}
-            self._failed_import_hooks = []
-            self.always_load_extensions = False
-            self.optimize_ast = False
-            self.extension_package_whitelist = set()
-            self._transform = transforms.TransformVisitor()
-
-            # Export these APIs for convenience
-            self.register_transform = self._transform.register_transform
-            self.unregister_transform = self._transform.unregister_transform
-
-    def visit_transforms(self, node):
-        """Visit the transforms and apply them to the given *node*."""
-        return self._transform.visit(node)
-
-    def ast_from_file(self, filepath, modname=None, fallback=True, source=False):
-        """given a module name, return the astroid object"""
-        try:
-            filepath = modutils.get_source_file(filepath, include_no_ext=True)
-            source = True
-        except modutils.NoSourceFile:
-            pass
-        if modname is None:
-            try:
-                modname = '.'.join(modutils.modpath_from_file(filepath))
-            except ImportError:
-                modname = filepath
-        if modname in self.astroid_cache and self.astroid_cache[modname].source_file == filepath:
-            return self.astroid_cache[modname]
-        if source:
-            from astroid.builder import AstroidBuilder
-            return AstroidBuilder(self).file_build(filepath, modname)
-        elif fallback and modname:
-            return self.ast_from_module_name(modname)
-        raise exceptions.AstroidBuildingException(
-            'unable to get astroid for file %s' % filepath)
-
-    def _build_stub_module(self, modname):
-        from astroid.builder import AstroidBuilder
-        return AstroidBuilder(self).string_build('', modname)
-
-    def _can_load_extension(self, modname):
-        if self.always_load_extensions:
-            return True
-        if modutils.is_standard_module(modname):
-            return True
-        parts = modname.split('.')
-        return any(
-            '.'.join(parts[:x]) in self.extension_package_whitelist
-            for x in range(1, len(parts) + 1))
-
-    def ast_from_module_name(self, modname, context_file=None):
-        """given a module name, return the astroid object"""
-        if modname in self.astroid_cache:
-            return self.astroid_cache[modname]
-        if modname == '__main__':
-            return self._build_stub_module(modname)
-        old_cwd = os.getcwd()
-        if context_file:
-            os.chdir(os.path.dirname(context_file))
-        try:
-            filepath, mp_type = self.file_from_module_name(modname, context_file)
-            if mp_type == modutils.PY_ZIPMODULE:
-                module = self.zip_import_data(filepath)
-                if module is not None:
-                    return module
-            elif mp_type in (imp.C_BUILTIN, imp.C_EXTENSION):
-                if mp_type == imp.C_EXTENSION and not self._can_load_extension(modname):
-                    return self._build_stub_module(modname)
-                try:
-                    module = modutils.load_module_from_name(modname)
-                except Exception as ex:
-                    msg = 'Unable to load module %s (%s)' % (modname, ex)
-                    raise exceptions.AstroidBuildingException(msg)
-                return self.ast_from_module(module, modname)
-            elif mp_type == imp.PY_COMPILED:
-                msg = "Unable to load compiled module %s" % (modname,)
-                raise exceptions.AstroidBuildingException(msg)
-            if filepath is None:
-                msg = "Unable to load module %s" % (modname,)
-                raise exceptions.AstroidBuildingException(msg)
-            return self.ast_from_file(filepath, modname, fallback=False)
-        except exceptions.AstroidBuildingException as e:
-            for hook in self._failed_import_hooks:
-                try:
-                    return hook(modname)
-                except exceptions.AstroidBuildingException:
-                    pass
-            raise e
-        finally:
-            os.chdir(old_cwd)
-
-    def zip_import_data(self, filepath):
-        if zipimport is None:
-            return None
-        from astroid.builder import AstroidBuilder
-        builder = AstroidBuilder(self)
-        for ext in ('.zip', '.egg'):
-            try:
-                eggpath, resource = filepath.rsplit(ext + os.path.sep, 1)
-            except ValueError:
-                continue
-            try:
-                importer = zipimport.zipimporter(eggpath + ext)
-                zmodname = resource.replace(os.path.sep, '.')
-                if importer.is_package(resource):
-                    zmodname = zmodname + '.__init__'
-                module = builder.string_build(importer.get_source(resource),
-                                              zmodname, filepath)
-                return module
-            except Exception: # pylint: disable=broad-except
-                continue
-        return None
-
-    def file_from_module_name(self, modname, contextfile):
-        # pylint: disable=redefined-variable-type
-        try:
-            value = self._mod_file_cache[(modname, contextfile)]
-        except KeyError:
-            try:
-                value = modutils.file_info_from_modpath(
-                    modname.split('.'), context_file=contextfile)
-            except ImportError as ex:
-                msg = 'Unable to load module %s (%s)' % (modname, ex)
-                value = exceptions.AstroidBuildingException(msg)
-            self._mod_file_cache[(modname, contextfile)] = value
-        if isinstance(value, exceptions.AstroidBuildingException):
-            raise value
-        return value
-
-    def ast_from_module(self, module, modname=None):
-        """given an imported module, return the astroid object"""
-        modname = modname or module.__name__
-        if modname in self.astroid_cache:
-            return self.astroid_cache[modname]
-        try:
-            # some builtin modules don't have __file__ attribute
-            filepath = module.__file__
-            if modutils.is_python_source(filepath):
-                return self.ast_from_file(filepath, modname)
-        except AttributeError:
-            pass
-        from astroid.builder import AstroidBuilder
-        return AstroidBuilder(self).module_build(module, modname)
-
-    def ast_from_class(self, klass, modname=None):
-        """get astroid for the given class"""
-        if modname is None:
-            try:
-                modname = klass.__module__
-            except AttributeError:
-                msg = 'Unable to get module for class %s' % safe_repr(klass)
-                raise exceptions.AstroidBuildingException(msg)
-        modastroid = self.ast_from_module_name(modname)
-        return modastroid.getattr(klass.__name__)[0] # XXX
-
-    def infer_ast_from_something(self, obj, context=None):
-        """infer astroid for the given class"""
-        if hasattr(obj, '__class__') and not isinstance(obj, type):
-            klass = obj.__class__
-        else:
-            klass = obj
-        try:
-            modname = klass.__module__
-        except AttributeError:
-            msg = 'Unable to get module for %s' % safe_repr(klass)
-            raise exceptions.AstroidBuildingException(msg)
-        except Exception as ex:
-            msg = ('Unexpected error while retrieving module for %s: %s'
-                   % (safe_repr(klass), ex))
-            raise exceptions.AstroidBuildingException(msg)
-        try:
-            name = klass.__name__
-        except AttributeError:
-            msg = 'Unable to get name for %s' % safe_repr(klass)
-            raise exceptions.AstroidBuildingException(msg)
-        except Exception as ex:
-            exc = ('Unexpected error while retrieving name for %s: %s'
-                   % (safe_repr(klass), ex))
-            raise exceptions.AstroidBuildingException(exc)
-        # take care, on living object __module__ is regularly wrong :(
-        modastroid = self.ast_from_module_name(modname)
-        if klass is obj:
-            for inferred in modastroid.igetattr(name, context):
-                yield inferred
-        else:
-            for inferred in modastroid.igetattr(name, context):
-                yield inferred.instantiate_class()
-
-    def register_failed_import_hook(self, hook):
-        """Registers a hook to resolve imports that cannot be found otherwise.
-
-        `hook` must be a function that accepts a single argument `modname` which
-        contains the name of the module or package that could not be imported.
-        If `hook` can resolve the import, must return a node of type `astroid.Module`,
-        otherwise, it must raise `AstroidBuildingException`.
-        """
-        self._failed_import_hooks.append(hook)
-
-    def cache_module(self, module):
-        """Cache a module if no module with the same name is known yet."""
-        self.astroid_cache.setdefault(module.name, module)
-
-    def clear_cache(self, astroid_builtin=None):
-        # XXX clear transforms
-        self.astroid_cache.clear()
-        # force bootstrap again, else we may ends up with cache inconsistency
-        # between the manager and CONST_PROXY, making
-        # unittest_lookup.LookupTC.test_builtin_lookup fail depending on the
-        # test order
-        import astroid.raw_building
-        astroid.raw_building._astroid_bootstrapping(
-            astroid_builtin=astroid_builtin)