libv8 7.3.492.27.0 → 8.4.255.0

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

@@ -1,86 +0,0 @@
-# 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/>.
-"""Small AST optimizations."""
-
-import _ast
-
-from astroid import nodes
-
-
-__all__ = ('ASTPeepholeOptimizer', )
-
-
-try:
-    _TYPES = (_ast.Str, _ast.Bytes)
-except AttributeError:
-    _TYPES = (_ast.Str, )
-
-
-class ASTPeepholeOptimizer(object):
-    """Class for applying small optimizations to generate new AST."""
-
-    def optimize_binop(self, node):
-        """Optimize BinOps with string Const nodes on the lhs.
-
-        This fixes an infinite recursion crash, where multiple
-        strings are joined using the addition operator. With a
-        sufficient number of such strings, astroid will fail
-        with a maximum recursion limit exceeded. The
-        function will return a Const node with all the strings
-        already joined.
-        Return ``None`` if no AST node can be obtained
-        through optimization.
-        """
-        ast_nodes = []
-        current = node
-        while isinstance(current, _ast.BinOp):
-            # lhs must be a BinOp with the addition operand.
-            if not isinstance(current.left, _ast.BinOp):
-                return
-            if (not isinstance(current.left.op, _ast.Add)
-                    or not isinstance(current.op, _ast.Add)):
-                return
-
-            # rhs must a str / bytes.
-            if not isinstance(current.right, _TYPES):
-                return
-
-            ast_nodes.append(current.right.s)
-            current = current.left
-
-            if (isinstance(current, _ast.BinOp)
-                    and isinstance(current.left, _TYPES)
-                    and isinstance(current.right, _TYPES)):
-                # Stop early if we are at the last BinOp in
-                # the operation
-                ast_nodes.append(current.right.s)
-                ast_nodes.append(current.left.s)
-                break
-
-        if not ast_nodes:
-            return
-
-        # If we have inconsistent types, bail out.
-        known = type(ast_nodes[0])
-        if any(type(element) is not known
-               for element in ast_nodes[1:]):
-            return
-
-        value = known().join(reversed(ast_nodes))
-        newnode = nodes.Const(value)
-        return newnode

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

@@ -1,636 +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 base classes and functions for the nodes and some
-inference utils.
-"""
-import functools
-import sys
-import warnings
-
-import wrapt
-
-from astroid import context as contextmod
-from astroid import decorators as decoratorsmod
-from astroid import exceptions
-from astroid import util
-
-
-if sys.version_info >= (3, 0):
-    BUILTINS = 'builtins'
-else:
-    BUILTINS = '__builtin__'
-PROPERTIES = {BUILTINS + '.property', 'abc.abstractproperty'}
-# List of possible property names. We use this list in order
-# to see if a method is a property or not. This should be
-# pretty reliable and fast, the alternative being to check each
-# decorator to see if its a real property-like descriptor, which
-# can be too complicated.
-# Also, these aren't qualified, because each project can
-# define them, we shouldn't expect to know every possible
-# property-like decorator!
-# TODO(cpopa): just implement descriptors already.
-POSSIBLE_PROPERTIES = {"cached_property", "cachedproperty",
-                       "lazyproperty", "lazy_property", "reify",
-                       "lazyattribute", "lazy_attribute",
-                       "LazyProperty", "lazy"}
-
-
-def _is_property(meth):
-    if PROPERTIES.intersection(meth.decoratornames()):
-        return True
-    stripped = {name.split(".")[-1] for name in meth.decoratornames()
-                if name is not util.YES}
-    return any(name in stripped for name in POSSIBLE_PROPERTIES)
-
-
-class Proxy(object):
-    """a simple proxy object"""
-
-    _proxied = None # proxied object may be set by class or by instance
-
-    def __init__(self, proxied=None):
-        if proxied is not None:
-            self._proxied = proxied
-
-    def __getattr__(self, name):
-        if name == '_proxied':
-            return getattr(self.__class__, '_proxied')
-        if name in self.__dict__:
-            return self.__dict__[name]
-        return getattr(self._proxied, name)
-
-    def infer(self, context=None):
-        yield self
-
-
-def _infer_stmts(stmts, context, frame=None):
-    """Return an iterator on statements inferred by each statement in *stmts*."""
-    stmt = None
-    inferred = False
-    if context is not None:
-        name = context.lookupname
-        context = context.clone()
-    else:
-        name = None
-        context = contextmod.InferenceContext()
-
-    for stmt in stmts:
-        if stmt is util.YES:
-            yield stmt
-            inferred = True
-            continue
-        context.lookupname = stmt._infer_name(frame, name)
-        try:
-            for inferred in stmt.infer(context=context):
-                yield inferred
-                inferred = True
-        except exceptions.UnresolvableName:
-            continue
-        except exceptions.InferenceError:
-            yield util.YES
-            inferred = True
-    if not inferred:
-        raise exceptions.InferenceError(str(stmt))
-
-
-class Instance(Proxy):
-    """a special node representing a class instance"""
-    def getattr(self, name, context=None, lookupclass=True):
-        try:
-            values = self._proxied.instance_attr(name, context)
-        except exceptions.NotFoundError:
-            if name == '__class__':
-                return [self._proxied]
-            if lookupclass:
-                # class attributes not available through the instance
-                # unless they are explicitly defined
-                if name in ('__name__', '__bases__', '__mro__', '__subclasses__'):
-                    return self._proxied.local_attr(name)
-                return self._proxied.getattr(name, context)
-            raise exceptions.NotFoundError(name)
-        # since we've no context information, return matching class members as
-        # well
-        if lookupclass:
-            try:
-                return values + self._proxied.getattr(name, context)
-            except exceptions.NotFoundError:
-                pass
-        return values
-
-    def igetattr(self, name, context=None):
-        """inferred getattr"""
-        if not context:
-            context = contextmod.InferenceContext()
-        try:
-            # avoid recursively inferring the same attr on the same class
-            context.push((self._proxied, name))
-            # XXX frame should be self._proxied, or not ?
-            get_attr = self.getattr(name, context, lookupclass=False)
-            return _infer_stmts(
-                self._wrap_attr(get_attr, context),
-                context,
-                frame=self,
-            )
-        except exceptions.NotFoundError:
-            try:
-                # fallback to class'igetattr since it has some logic to handle
-                # descriptors
-                return self._wrap_attr(self._proxied.igetattr(name, context),
-                                       context)
-            except exceptions.NotFoundError:
-                raise exceptions.InferenceError(name)
-
-    def _wrap_attr(self, attrs, context=None):
-        """wrap bound methods of attrs in a InstanceMethod proxies"""
-        for attr in attrs:
-            if isinstance(attr, UnboundMethod):
-                if _is_property(attr):
-                    for inferred in attr.infer_call_result(self, context):
-                        yield inferred
-                else:
-                    yield BoundMethod(attr, self)
-            elif hasattr(attr, 'name') and attr.name == '<lambda>':
-                # This is a lambda function defined at class level,
-                # since its scope is the underlying _proxied class.
-                # Unfortunately, we can't do an isinstance check here,
-                # because of the circular dependency between astroid.bases
-                # and astroid.scoped_nodes.
-                if attr.statement().scope() == self._proxied:
-                    if attr.args.args and attr.args.args[0].name == 'self':
-                        yield BoundMethod(attr, self)
-                        continue
-                yield attr
-            else:
-                yield attr
-
-    def infer_call_result(self, caller, context=None):
-        """infer what a class instance is returning when called"""
-        inferred = False
-        for node in self._proxied.igetattr('__call__', context):
-            if node is util.YES or not node.callable():
-                continue
-            for res in node.infer_call_result(caller, context):
-                inferred = True
-                yield res
-        if not inferred:
-            raise exceptions.InferenceError()
-
-    def __repr__(self):
-        return '<Instance of %s.%s at 0x%s>' % (self._proxied.root().name,
-                                                self._proxied.name,
-                                                id(self))
-    def __str__(self):
-        return 'Instance of %s.%s' % (self._proxied.root().name,
-                                      self._proxied.name)
-
-    def callable(self):
-        try:
-            self._proxied.getattr('__call__')
-            return True
-        except exceptions.NotFoundError:
-            return False
-
-    def pytype(self):
-        return self._proxied.qname()
-
-    def display_type(self):
-        return 'Instance of'
-
-
-    # TODO(cpopa): this is set in inference.py
-    # The circular dependency hell goes deeper and deeper.
-    # pylint: disable=unused-argument
-    def getitem(self, index, context=None):
-        pass
-
-class UnboundMethod(Proxy):
-    """a special node representing a method not bound to an instance"""
-    def __repr__(self):
-        frame = self._proxied.parent.frame()
-        return '<%s %s of %s at 0x%s' % (self.__class__.__name__,
-                                         self._proxied.name,
-                                         frame.qname(), id(self))
-
-    def is_bound(self):
-        return False
-
-    def getattr(self, name, context=None):
-        if name == 'im_func':
-            return [self._proxied]
-        return self._proxied.getattr(name, context)
-
-    def igetattr(self, name, context=None):
-        if name == 'im_func':
-            return iter((self._proxied,))
-        return self._proxied.igetattr(name, context)
-
-    def infer_call_result(self, caller, context):
-        # If we're unbound method __new__ of builtin object, the result is an
-        # instance of the class given as first argument.
-        if (self._proxied.name == '__new__' and
-                self._proxied.parent.frame().qname() == '%s.object' % BUILTINS):
-            infer = caller.args[0].infer() if caller.args else []
-            return ((x is util.YES and x or Instance(x)) for x in infer)
-        return self._proxied.infer_call_result(caller, context)
-
-
-class BoundMethod(UnboundMethod):
-    """a special node representing a method bound to an instance"""
-    def __init__(self, proxy, bound):
-        UnboundMethod.__init__(self, proxy)
-        self.bound = bound
-
-    def is_bound(self):
-        return True
-
-    def infer_call_result(self, caller, context=None):
-
-        if context is None:
-            context = contextmod.InferenceContext()
-        context = context.clone()
-        context.boundnode = self.bound
-        return super(BoundMethod, self).infer_call_result(caller, context)
-
-
-class Generator(Instance):
-    """a special node representing a generator.
-
-    Proxied class is set once for all in raw_building.
-    """
-    def callable(self):
-        return False
-
-    def pytype(self):
-        return '%s.generator' % BUILTINS
-
-    def display_type(self):
-        return 'Generator'
-
-    def __repr__(self):
-        return '<Generator(%s) l.%s at 0x%s>' % (self._proxied.name, self.lineno, id(self))
-
-    def __str__(self):
-        return 'Generator(%s)' % (self._proxied.name)
-
-
-# decorators ##################################################################
-
-def path_wrapper(func):
-    """return the given infer function wrapped to handle the path"""
-    @functools.wraps(func)
-    def wrapped(node, context=None, _func=func, **kwargs):
-        """wrapper function handling context"""
-        if context is None:
-            context = contextmod.InferenceContext()
-        context.push(node)
-        yielded = set()
-        for res in _func(node, context, **kwargs):
-            # unproxy only true instance, not const, tuple, dict...
-            if res.__class__ is Instance:
-                ares = res._proxied
-            else:
-                ares = res
-            if ares not in yielded:
-                yield res
-                yielded.add(ares)
-    return wrapped
-
-@wrapt.decorator
-def yes_if_nothing_inferred(func, instance, args, kwargs):
-    inferred = False
-    for node in func(*args, **kwargs):
-        inferred = True
-        yield node
-    if not inferred:
-        yield util.YES
-
-@wrapt.decorator
-def raise_if_nothing_inferred(func, instance, args, kwargs):
-    inferred = False
-    for node in func(*args, **kwargs):
-        inferred = True
-        yield node
-    if not inferred:
-        raise exceptions.InferenceError()
-
-
-# Node  ######################################################################
-
-class NodeNG(object):
-    """Base Class for all Astroid node classes.
-
-    It represents a node of the new abstract syntax tree.
-    """
-    is_statement = False
-    optional_assign = False # True for For (and for Comprehension if py <3.0)
-    is_function = False # True for FunctionDef nodes
-    # attributes below are set by the builder module or by raw factories
-    lineno = None
-    fromlineno = None
-    tolineno = None
-    col_offset = None
-    # parent node in the tree
-    parent = None
-    # attributes containing child node(s) redefined in most concrete classes:
-    _astroid_fields = ()
-    # instance specific inference function infer(node, context)
-    _explicit_inference = None
-
-    def infer(self, context=None, **kwargs):
-        """main interface to the interface system, return a generator on infered
-        values.
-
-        If the instance has some explicit inference function set, it will be
-        called instead of the default interface.
-        """
-        if self._explicit_inference is not None:
-            # explicit_inference is not bound, give it self explicitly
-            try:
-                return self._explicit_inference(self, context, **kwargs)
-            except exceptions.UseInferenceDefault:
-                pass
-
-        if not context:
-            return self._infer(context, **kwargs)
-
-        key = (self, context.lookupname,
-               context.callcontext, context.boundnode)
-        if key in context.inferred:
-            return iter(context.inferred[key])
-
-        return context.cache_generator(key, self._infer(context, **kwargs))
-
-    def _repr_name(self):
-        """return self.name or self.attrname or '' for nice representation"""
-        return getattr(self, 'name', getattr(self, 'attrname', ''))
-
-    def __str__(self):
-        return '%s(%s)' % (self.__class__.__name__, self._repr_name())
-
-    def __repr__(self):
-        return '<%s(%s) l.%s [%s] at 0x%x>' % (self.__class__.__name__,
-                                               self._repr_name(),
-                                               self.fromlineno,
-                                               self.root().name,
-                                               id(self))
-
-
-    def accept(self, visitor):
-        func = getattr(visitor, "visit_" + self.__class__.__name__.lower())
-        return func(self)
-
-    def get_children(self):
-        for field in self._astroid_fields:
-            attr = getattr(self, field)
-            if attr is None:
-                continue
-            if isinstance(attr, (list, tuple)):
-                for elt in attr:
-                    yield elt
-            else:
-                yield attr
-
-    def last_child(self):
-        """an optimized version of list(get_children())[-1]"""
-        for field in self._astroid_fields[::-1]:
-            attr = getattr(self, field)
-            if not attr: # None or empty listy / tuple
-                continue
-            if isinstance(attr, (list, tuple)):
-                return attr[-1]
-            else:
-                return attr
-        return None
-
-    def parent_of(self, node):
-        """return true if i'm a parent of the given node"""
-        parent = node.parent
-        while parent is not None:
-            if self is parent:
-                return True
-            parent = parent.parent
-        return False
-
-    def statement(self):
-        """return the first parent node marked as statement node"""
-        if self.is_statement:
-            return self
-        return self.parent.statement()
-
-    def frame(self):
-        """return the first parent frame node (i.e. Module, FunctionDef or
-        ClassDef)
-
-        """
-        return self.parent.frame()
-
-    def scope(self):
-        """return the first node defining a new scope (i.e. Module,
-        FunctionDef, ClassDef, Lambda but also GenExpr)
-
-        """
-        return self.parent.scope()
-
-    def root(self):
-        """return the root node of the tree, (i.e. a Module)"""
-        if self.parent:
-            return self.parent.root()
-        return self
-
-    def child_sequence(self, child):
-        """search for the right sequence where the child lies in"""
-        for field in self._astroid_fields:
-            node_or_sequence = getattr(self, field)
-            if node_or_sequence is child:
-                return [node_or_sequence]
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if (isinstance(node_or_sequence, (tuple, list))
-                    and child in node_or_sequence):
-                return node_or_sequence
-
-        msg = 'Could not find %s in %s\'s children'
-        raise exceptions.AstroidError(msg % (repr(child), repr(self)))
-
-    def locate_child(self, child):
-        """return a 2-uple (child attribute name, sequence or node)"""
-        for field in self._astroid_fields:
-            node_or_sequence = getattr(self, field)
-            # /!\ compiler.ast Nodes have an __iter__ walking over child nodes
-            if child is node_or_sequence:
-                return field, child
-            if isinstance(node_or_sequence, (tuple, list)) and child in node_or_sequence:
-                return field, node_or_sequence
-        msg = 'Could not find %s in %s\'s children'
-        raise exceptions.AstroidError(msg % (repr(child), repr(self)))
-    # FIXME : should we merge child_sequence and locate_child ? locate_child
-    # is only used in are_exclusive, child_sequence one time in pylint.
-
-    def next_sibling(self):
-        """return the next sibling statement"""
-        return self.parent.next_sibling()
-
-    def previous_sibling(self):
-        """return the previous sibling statement"""
-        return self.parent.previous_sibling()
-
-    def nearest(self, nodes):
-        """return the node which is the nearest before this one in the
-        given list of nodes
-        """
-        myroot = self.root()
-        mylineno = self.fromlineno
-        nearest = None, 0
-        for node in nodes:
-            assert node.root() is myroot, \
-                   'nodes %s and %s are not from the same module' % (self, node)
-            lineno = node.fromlineno
-            if node.fromlineno > mylineno:
-                break
-            if lineno > nearest[1]:
-                nearest = node, lineno
-        # FIXME: raise an exception if nearest is None ?
-        return nearest[0]
-
-    # these are lazy because they're relatively expensive to compute for every
-    # single node, and they rarely get looked at
-
-    @decoratorsmod.cachedproperty
-    def fromlineno(self):
-        if self.lineno is None:
-            return self._fixed_source_line()
-        else:
-            return self.lineno
-
-    @decoratorsmod.cachedproperty
-    def tolineno(self):
-        if not self._astroid_fields:
-            # can't have children
-            lastchild = None
-        else:
-            lastchild = self.last_child()
-        if lastchild is None:
-            return self.fromlineno
-        else:
-            return lastchild.tolineno
-
-        # TODO / FIXME:
-        assert self.fromlineno is not None, self
-        assert self.tolineno is not None, self
-
-    def _fixed_source_line(self):
-        """return the line number where the given node appears
-
-        we need this method since not all nodes have the lineno attribute
-        correctly set...
-        """
-        line = self.lineno
-        _node = self
-        try:
-            while line is None:
-                _node = next(_node.get_children())
-                line = _node.lineno
-        except StopIteration:
-            _node = self.parent
-            while _node and line is None:
-                line = _node.lineno
-                _node = _node.parent
-        return line
-
-    def block_range(self, lineno):
-        """handle block line numbers range for non block opening statements
-        """
-        return lineno, self.tolineno
-
-    def set_local(self, name, stmt):
-        """delegate to a scoped parent handling a locals dictionary"""
-        self.parent.set_local(name, stmt)
-
-    def nodes_of_class(self, klass, skip_klass=None):
-        """return an iterator on nodes which are instance of the given class(es)
-
-        klass may be a class object or a tuple of class objects
-        """
-        if isinstance(self, klass):
-            yield self
-        for child_node in self.get_children():
-            if skip_klass is not None and isinstance(child_node, skip_klass):
-                continue
-            for matching in child_node.nodes_of_class(klass, skip_klass):
-                yield matching
-
-    def _infer_name(self, frame, name):
-        # overridden for ImportFrom, Import, Global, TryExcept and Arguments
-        return None
-
-    def _infer(self, context=None):
-        """we don't know how to resolve a statement by default"""
-        # this method is overridden by most concrete classes
-        raise exceptions.InferenceError(self.__class__.__name__)
-
-    def inferred(self):
-        '''return list of inferred values for a more simple inference usage'''
-        return list(self.infer())
-
-    def infered(self):
-        warnings.warn('%s.infered() is deprecated and slated for removal '
-                      'in astroid 2.0, use %s.inferred() instead.'
-                      % (type(self).__name__, type(self).__name__),
-                      PendingDeprecationWarning, stacklevel=2)
-        return self.inferred()
-
-    def instanciate_class(self):
-        """instanciate a node if it is a ClassDef node, else return self"""
-        return self
-
-    def has_base(self, node):
-        return False
-
-    def callable(self):
-        return False
-
-    def eq(self, value):
-        return False
-
-    def as_string(self):
-        from astroid.as_string import to_code
-        return to_code(self)
-
-    def repr_tree(self, ids=False):
-        from astroid.as_string import dump
-        return dump(self)
-
-
-class Statement(NodeNG):
-    """Statement node adding a few attributes"""
-    is_statement = True
-
-    def next_sibling(self):
-        """return the next sibling statement"""
-        stmts = self.parent.child_sequence(self)
-        index = stmts.index(self)
-        try:
-            return stmts[index +1]
-        except IndexError:
-            pass
-
-    def previous_sibling(self):
-        """return the previous sibling statement"""
-        stmts = self.parent.child_sequence(self)
-        index = stmts.index(self)
-        if index >= 1:
-            return stmts[index -1]