libv8 7.8.279.23.0beta1 → 8.4.255.0

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

@@ -1,87 +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/>.
-"""
-on all nodes :
- .is_statement, returning true if the node should be considered as a
-  statement node
- .root(), returning the root node of the tree (i.e. a Module)
- .previous_sibling(), returning previous sibling statement node
- .next_sibling(), returning next sibling statement node
- .statement(), returning the first parent node marked as statement node
- .frame(), returning the first node defining a new local scope (i.e.
-  Module, FunctionDef or ClassDef)
- .set_local(name, node), define an identifier <name> on the first parent frame,
-  with the node defining it. This is used by the astroid builder and should not
-  be used from out there.
-
-on ImportFrom and Import :
- .real_name(name),
-
-
-"""
-# pylint: disable=unused-import,redefined-builtin
-
-from astroid.node_classes import (
-    Arguments, AssignAttr, Assert, Assign,
-    AssignName, AugAssign, Repr, BinOp, BoolOp, Break, Call, Compare,
-    Comprehension, Const, Continue, Decorators, DelAttr, DelName, Delete,
-    Dict, Expr, Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice, For,
-    ImportFrom, Attribute, Global, If, IfExp, Import, Index, Keyword,
-    List, Name, Nonlocal, Pass, Print, Raise, Return, Set, Slice, Starred, Subscript,
-    TryExcept, TryFinally, Tuple, UnaryOp, While, With, Yield, YieldFrom,
-    const_factory,
-    AsyncFor, Await, AsyncWith,
-    # Backwards-compatibility aliases
-    Backquote, Discard, AssName, AssAttr, Getattr, CallFunc, From,
-    # Node not present in the builtin ast module.
-    DictUnpack,
-)
-from astroid.scoped_nodes import (
-    Module, GeneratorExp, Lambda, DictComp,
-    ListComp, SetComp, FunctionDef, ClassDef,
-    AsyncFunctionDef,
-    # Backwards-compatibility aliases
-    Class, Function, GenExpr,
-)
-
-
-
-ALL_NODE_CLASSES = (
-    AsyncFunctionDef, AsyncFor, AsyncWith, Await,
-
-    Arguments, AssignAttr, Assert, Assign, AssignName, AugAssign,
-    Repr, BinOp, BoolOp, Break,
-    Call, ClassDef, Compare, Comprehension, Const, Continue,
-    Decorators, DelAttr, DelName, Delete,
-    Dict, DictComp, DictUnpack, Expr,
-    Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice,
-    For, ImportFrom, FunctionDef,
-    Attribute, GeneratorExp, Global,
-    If, IfExp, Import, Index,
-    Keyword,
-    Lambda, List, ListComp,
-    Name, Nonlocal,
-    Module,
-    Pass, Print,
-    Raise, Return,
-    Set, SetComp, Slice, Starred, Subscript,
-    TryExcept, TryFinally, Tuple,
-    UnaryOp,
-    While, With,
-    Yield, YieldFrom,
-    )

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

@@ -1,186 +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/>.
-
-"""
-Inference objects are a way to represent composite AST nodes,
-which are used only as inference results, so they can't be found in the
-code tree. For instance, inferring the following frozenset use, leads to an
-inferred FrozenSet:
-
-    CallFunc(func=Name('frozenset'), args=Tuple(...))
-
-"""
-
-import six
-
-from astroid import MANAGER
-from astroid.bases import (
-    BUILTINS, NodeNG, Instance, _infer_stmts,
-    BoundMethod, _is_property
-)
-from astroid.decorators import cachedproperty
-from astroid.exceptions import (
-    SuperError, SuperArgumentTypeError,
-    NotFoundError, MroError
-)
-from astroid.node_classes import const_factory
-from astroid.scoped_nodes import ClassDef, FunctionDef
-from astroid.mixins import ParentAssignTypeMixin
-
-
-class FrozenSet(NodeNG, Instance, ParentAssignTypeMixin):
-    """class representing a FrozenSet composite node"""
-
-    def __init__(self, elts=None):
-        if elts is None:
-            self.elts = []
-        else:
-            self.elts = [const_factory(e) for e in elts]
-
-    def pytype(self):
-        return '%s.frozenset' % BUILTINS
-
-    def itered(self):
-        return self.elts
-
-    def _infer(self, context=None):
-        yield self
-
-    @cachedproperty
-    def _proxied(self):
-        builtins = MANAGER.astroid_cache[BUILTINS]
-        return builtins.getattr('frozenset')[0]
-
-
-class Super(NodeNG):
-    """Proxy class over a super call.
-
-    This class offers almost the same behaviour as Python's super,
-    which is MRO lookups for retrieving attributes from the parents.
-
-    The *mro_pointer* is the place in the MRO from where we should
-    start looking, not counting it. *mro_type* is the object which
-    provides the MRO, it can be both a type or an instance.
-    *self_class* is the class where the super call is, while
-    *scope* is the function where the super call is.
-    """
-
-    def __init__(self, mro_pointer, mro_type, self_class, scope):
-        self.type = mro_type
-        self.mro_pointer = mro_pointer
-        self._class_based = False
-        self._self_class = self_class
-        self._scope = scope
-        self._model = {
-            '__thisclass__': self.mro_pointer,
-            '__self_class__': self._self_class,
-            '__self__': self.type,
-            '__class__': self._proxied,
-        }
-
-    def _infer(self, context=None):
-        yield self
-
-    def super_mro(self):
-        """Get the MRO which will be used to lookup attributes in this super."""
-        if not isinstance(self.mro_pointer, ClassDef):
-            raise SuperArgumentTypeError("The first super argument must be type.")
-
-        if isinstance(self.type, ClassDef):
-            # `super(type, type)`, most likely in a class method.
-            self._class_based = True
-            mro_type = self.type
-        else:
-            mro_type = getattr(self.type, '_proxied', None)
-            if not isinstance(mro_type, (Instance, ClassDef)):
-                raise SuperArgumentTypeError("super(type, obj): obj must be an "
-                                             "instance or subtype of type")
-
-        if not mro_type.newstyle:
-            raise SuperError("Unable to call super on old-style classes.")
-
-        mro = mro_type.mro()
-        if self.mro_pointer not in mro:
-            raise SuperArgumentTypeError("super(type, obj): obj must be an "
-                                         "instance or subtype of type")
-
-        index = mro.index(self.mro_pointer)
-        return mro[index + 1:]
-
-    @cachedproperty
-    def _proxied(self):
-        builtins = MANAGER.astroid_cache[BUILTINS]
-        return builtins.getattr('super')[0]
-
-    def pytype(self):
-        return '%s.super' % BUILTINS
-
-    def display_type(self):
-        return 'Super of'
-
-    @property
-    def name(self):
-        """Get the name of the MRO pointer."""
-        return self.mro_pointer.name
-
-    def igetattr(self, name, context=None):
-        """Retrieve the inferred values of the given attribute name."""
-
-        local_name = self._model.get(name)
-        if local_name:
-            yield local_name
-            return
-
-        try:
-            mro = self.super_mro()
-        except (MroError, SuperError) as exc:
-            # Don't let invalid MROs or invalid super calls
-            # to leak out as is from this function.
-            six.raise_from(NotFoundError, exc)
-
-        found = False
-        for cls in mro:
-            if name not in cls._locals:
-                continue
-
-            found = True
-            for infered in _infer_stmts([cls[name]], context, frame=self):
-                if not isinstance(infered, FunctionDef):
-                    yield infered
-                    continue
-
-                # We can obtain different descriptors from a super depending
-                # on what we are accessing and where the super call is.
-                if infered.type == 'classmethod':
-                    yield BoundMethod(infered, cls)
-                elif self._scope.type == 'classmethod' and infered.type == 'method':
-                    yield infered
-                elif self._class_based or infered.type == 'staticmethod':
-                    yield infered
-                elif _is_property(infered):
-                    # TODO: support other descriptors as well.
-                    for value in infered.infer_call_result(self, context):
-                        yield value
-                else:
-                    yield BoundMethod(infered, cls)
-
-        if not found:
-            raise NotFoundError(name)
-
-    def getattr(self, name, context=None):
-        return list(self.igetattr(name, context=context))

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

@@ -1,470 +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 python protocols for nodes
-where it makes sense.
-"""
-
-import collections
-import operator
-import sys
-
-from astroid import arguments
-from astroid import bases
-from astroid import context as contextmod
-from astroid import exceptions
-from astroid import node_classes
-from astroid import nodes
-from astroid import util
-
-BIN_OP_METHOD = {'+':  '__add__',
-                 '-':  '__sub__',
-                 '/':  '__div__',
-                 '//': '__floordiv__',
-                 '*':  '__mul__',
-                 '**': '__pow__',
-                 '%':  '__mod__',
-                 '&':  '__and__',
-                 '|':  '__or__',
-                 '^':  '__xor__',
-                 '<<': '__lshift__',
-                 '>>': '__rshift__',
-                 '@': '__matmul__'
-                }
-
-UNARY_OP_METHOD = {'+': '__pos__',
-                   '-': '__neg__',
-                   '~': '__invert__',
-                   'not': None, # XXX not '__nonzero__'
-                  }
-
-# unary operations ############################################################
-
-def tl_infer_unary_op(self, operator):
-    if operator == 'not':
-        return node_classes.const_factory(not bool(self.elts))
-    raise TypeError() # XXX log unsupported operation
-nodes.Tuple.infer_unary_op = tl_infer_unary_op
-nodes.List.infer_unary_op = tl_infer_unary_op
-
-
-def dict_infer_unary_op(self, operator):
-    if operator == 'not':
-        return node_classes.const_factory(not bool(self.items))
-    raise TypeError() # XXX log unsupported operation
-nodes.Dict.infer_unary_op = dict_infer_unary_op
-
-
-def const_infer_unary_op(self, operator):
-    if operator == 'not':
-        return node_classes.const_factory(not self.value)
-    # XXX log potentially raised TypeError
-    elif operator == '+':
-        return node_classes.const_factory(+self.value)
-    else: # operator == '-':
-        return node_classes.const_factory(-self.value)
-nodes.Const.infer_unary_op = const_infer_unary_op
-
-
-# binary operations ###########################################################
-
-BIN_OP_IMPL = {'+':  lambda a, b: a + b,
-               '-':  lambda a, b: a - b,
-               '/':  lambda a, b: a / b,
-               '//': lambda a, b: a // b,
-               '*':  lambda a, b: a * b,
-               '**': lambda a, b: a ** b,
-               '%':  lambda a, b: a % b,
-               '&':  lambda a, b: a & b,
-               '|':  lambda a, b: a | b,
-               '^':  lambda a, b: a ^ b,
-               '<<': lambda a, b: a << b,
-               '>>': lambda a, b: a >> b,
-              }
-
-if sys.version_info >= (3, 5):
-    # MatMult is available since Python 3.5+.
-    BIN_OP_IMPL['@'] = operator.matmul
-
-for key, impl in list(BIN_OP_IMPL.items()):
-    BIN_OP_IMPL[key+'='] = impl
-
-def const_infer_binary_op(self, binop, other, context):
-    operator = binop.op
-    for other in other.infer(context):
-        if isinstance(other, nodes.Const):
-            try:
-                impl = BIN_OP_IMPL[operator]
-
-                try:
-                    yield node_classes.const_factory(impl(self.value, other.value))
-                except Exception:
-                    # ArithmeticError is not enough: float >> float is a TypeError
-                    # TODO : let pylint know about the problem
-                    pass
-            except TypeError:
-                # XXX log TypeError
-                continue
-        elif other is util.YES:
-            yield other
-        else:
-            try:
-                for val in other.infer_binary_op(binop, self, context):
-                    yield val
-            except AttributeError:
-                yield util.YES
-nodes.Const.infer_binary_op = bases.yes_if_nothing_inferred(const_infer_binary_op)
-
-
-
-def _multiply_seq_by_int(self, binop, other, context):
-    node = self.__class__()
-    node.parent = binop
-    elts = []
-    for elt in self.elts:
-        infered = util.safe_infer(elt, context)
-        if infered is None:
-            infered = util.YES
-        elts.append(infered)
-    node.elts = elts * other.value
-    return node
-
-
-def _filter_uninferable_nodes(elts, context):
-    for elt in elts:
-        if elt is util.YES:
-            yield elt
-        else:
-            for inferred in elt.infer(context):
-                yield inferred
-
-
-def tl_infer_binary_op(self, binop, other, context):
-    operator = binop.op
-    for other in other.infer(context):
-        if isinstance(other, self.__class__) and operator == '+':
-            node = self.__class__()
-            node.parent = binop
-            elts = list(_filter_uninferable_nodes(self.elts, context))
-            elts += list(_filter_uninferable_nodes(other.elts, context))
-            node.elts = elts
-            yield node
-        elif isinstance(other, nodes.Const) and operator == '*':
-            if not isinstance(other.value, int):
-                yield util.YES
-                continue
-            yield _multiply_seq_by_int(self, binop, other, context)
-        elif isinstance(other, bases.Instance) and not isinstance(other, nodes.Const):
-            yield util.YES
-    # XXX else log TypeError
-nodes.Tuple.infer_binary_op = bases.yes_if_nothing_inferred(tl_infer_binary_op)
-nodes.List.infer_binary_op = bases.yes_if_nothing_inferred(tl_infer_binary_op)
-
-
-def dict_infer_binary_op(self, binop, other, context):
-    for other in other.infer(context):
-        if isinstance(other, bases.Instance) and isinstance(other._proxied, nodes.ClassDef):
-            yield util.YES
-        # XXX else log TypeError
-nodes.Dict.infer_binary_op = bases.yes_if_nothing_inferred(dict_infer_binary_op)
-
-def instance_infer_binary_op(self, binop, other, context):
-    operator = binop.op
-    try:
-        methods = self.getattr(BIN_OP_METHOD[operator])
-    except (exceptions.NotFoundError, KeyError):
-        # Unknown operator
-        yield util.YES
-    else:
-        for method in methods:
-            if not isinstance(method, nodes.FunctionDef):
-                continue
-            for result in method.infer_call_result(self, context):
-                if result is not util.YES:
-                    yield result
-            # We are interested only in the first infered method,
-            # don't go looking in the rest of the methods of the ancestors.
-            break
-
-bases.Instance.infer_binary_op = bases.yes_if_nothing_inferred(instance_infer_binary_op)
-
-
-# assignment ##################################################################
-
-"""the assigned_stmts method is responsible to return the assigned statement
-(e.g. not inferred) according to the assignment type.
-
-The `asspath` argument is used to record the lhs path of the original node.
-For instance if we want assigned statements for 'c' in 'a, (b,c)', asspath
-will be [1, 1] once arrived to the Assign node.
-
-The `context` argument is the current inference context which should be given
-to any intermediary inference necessary.
-"""
-
-def _resolve_looppart(parts, asspath, context):
-    """recursive function to resolve multiple assignments on loops"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if part is util.YES:
-            continue
-        # XXX handle __iter__ and log potentially detected errors
-        if not hasattr(part, 'itered'):
-            continue
-        try:
-            itered = part.itered()
-        except TypeError:
-            continue # XXX log error
-        for stmt in itered:
-            try:
-                assigned = stmt.getitem(index, context)
-            except (AttributeError, IndexError):
-                continue
-            except TypeError: # stmt is unsubscriptable Const
-                continue
-            if not asspath:
-                # we achieved to resolved the assignment path,
-                # don't infer the last part
-                yield assigned
-            elif assigned is util.YES:
-                break
-            else:
-                # we are not yet on the last part of the path
-                # search on each possibly inferred value
-                try:
-                    for inferred in _resolve_looppart(assigned.infer(context),
-                                                     asspath, context):
-                        yield inferred
-                except exceptions.InferenceError:
-                    break
-
-
-@bases.raise_if_nothing_inferred
-def for_assigned_stmts(self, node=None, context=None, asspath=None):
-    if asspath is None:
-        for lst in self.iter.infer(context):
-            if isinstance(lst, (nodes.Tuple, nodes.List)):
-                for item in lst.elts:
-                    yield item
-    else:
-        for inferred in _resolve_looppart(self.iter.infer(context),
-                                         asspath, context):
-            yield inferred
-
-nodes.For.assigned_stmts = for_assigned_stmts
-nodes.Comprehension.assigned_stmts = for_assigned_stmts
-
-
-def sequence_assigned_stmts(self, node=None, context=None, asspath=None):
-    if asspath is None:
-        asspath = []
-    try:
-        index = self.elts.index(node)
-    except ValueError:
-         util.reraise(exceptions.InferenceError(
-             'Tried to retrieve a node {node!r} which does not exist',
-             node=self, assign_path=asspath, context=context))
-
-    asspath.insert(0, index)
-    return self.parent.assigned_stmts(node=self, context=context, asspath=asspath)
-
-nodes.Tuple.assigned_stmts = sequence_assigned_stmts
-nodes.List.assigned_stmts = sequence_assigned_stmts
-
-
-def assend_assigned_stmts(self, node=None, context=None, asspath=None):
-    return self.parent.assigned_stmts(node=self, context=context)
-nodes.AssignName.assigned_stmts = assend_assigned_stmts
-nodes.AssignAttr.assigned_stmts = assend_assigned_stmts
-
-
-def _arguments_infer_argname(self, name, context):
-    # arguments information may be missing, in which case we can't do anything
-    # more
-    if not (self.args or self.vararg or self.kwarg):
-        yield util.YES
-        return
-    # first argument of instance/class method
-    if self.args and getattr(self.args[0], 'name', None) == name:
-        functype = self.parent.type
-        if functype == 'method':
-            yield bases.Instance(self.parent.parent.frame())
-            return
-        if functype == 'classmethod':
-            yield self.parent.parent.frame()
-            return
-
-    if context and context.callcontext:
-        call_site = arguments.CallSite(context.callcontext)
-        for value in call_site.infer_argument(self.parent, name, context):
-            yield value
-        return
-
-    # TODO: just provide the type here, no need to have an empty Dict.
-    if name == self.vararg:
-        vararg = node_classes.const_factory(())
-        vararg.parent = self
-        yield vararg
-        return
-    if name == self.kwarg:
-        kwarg = node_classes.const_factory({})
-        kwarg.parent = self
-        yield kwarg
-        return
-    # if there is a default value, yield it. And then yield YES to reflect
-    # we can't guess given argument value
-    try:
-        context = contextmod.copy_context(context)
-        for inferred in self.default_value(name).infer(context):
-            yield inferred
-        yield util.YES
-    except exceptions.NoDefault:
-        yield util.YES
-
-
-def arguments_assigned_stmts(self, node=None, context=None, asspath=None):
-    if context.callcontext:
-        # reset call context/name
-        callcontext = context.callcontext
-        context = contextmod.copy_context(context)
-        context.callcontext = None
-        args = arguments.CallSite(callcontext)
-        return args.infer_argument(self.parent, node.name, context)
-    return _arguments_infer_argname(self, node.name, context)
-
-nodes.Arguments.assigned_stmts = arguments_assigned_stmts
-
-
-@bases.raise_if_nothing_inferred
-def assign_assigned_stmts(self, node=None, context=None, asspath=None):
-    if not asspath:
-        yield self.value
-        return
-    for inferred in _resolve_asspart(self.value.infer(context), asspath, context):
-        yield inferred
-
-nodes.Assign.assigned_stmts = assign_assigned_stmts
-nodes.AugAssign.assigned_stmts = assign_assigned_stmts
-
-
-def _resolve_asspart(parts, asspath, context):
-    """recursive function to resolve multiple assignments"""
-    asspath = asspath[:]
-    index = asspath.pop(0)
-    for part in parts:
-        if hasattr(part, 'getitem'):
-            try:
-                assigned = part.getitem(index, context)
-            # XXX raise a specific exception to avoid potential hiding of
-            # unexpected exception ?
-            except (TypeError, IndexError):
-                return
-            if not asspath:
-                # we achieved to resolved the assignment path, don't infer the
-                # last part
-                yield assigned
-            elif assigned is util.YES:
-                return
-            else:
-                # we are not yet on the last part of the path search on each
-                # possibly inferred value
-                try:
-                    for inferred in _resolve_asspart(assigned.infer(context),
-                                                    asspath, context):
-                        yield inferred
-                except exceptions.InferenceError:
-                    return
-
-
-@bases.raise_if_nothing_inferred
-def excepthandler_assigned_stmts(self, node=None, context=None, asspath=None):
-    for assigned in node_classes.unpack_infer(self.type):
-        if isinstance(assigned, nodes.ClassDef):
-            assigned = bases.Instance(assigned)
-        yield assigned
-nodes.ExceptHandler.assigned_stmts = bases.raise_if_nothing_inferred(excepthandler_assigned_stmts)
-
-
-@bases.raise_if_nothing_inferred
-def with_assigned_stmts(self, node=None, context=None, asspath=None):
-    if asspath is None:
-        for _, vars in self.items:
-            if vars is None:
-                continue
-            for lst in vars.infer(context):
-                if isinstance(lst, (nodes.Tuple, nodes.List)):
-                    for item in lst.nodes:
-                        yield item
-nodes.With.assigned_stmts = with_assigned_stmts
-
-
-@bases.yes_if_nothing_inferred
-def starred_assigned_stmts(self, node=None, context=None, asspath=None):
-    stmt = self.statement()
-    if not isinstance(stmt, (nodes.Assign, nodes.For)):
-        raise exceptions.InferenceError()
-
-    if isinstance(stmt, nodes.Assign):
-        value = stmt.value
-        lhs = stmt.targets[0]
-
-        if sum(1 for node in lhs.nodes_of_class(nodes.Starred)) > 1:
-            # Too many starred arguments in the expression.
-            raise exceptions.InferenceError()
-
-        if context is None:
-            context = contextmod.InferenceContext()
-        try:
-            rhs = next(value.infer(context))
-        except exceptions.InferenceError:
-            yield util.YES
-            return
-        if rhs is util.YES or not hasattr(rhs, 'elts'):
-            # Not interested in inferred values without elts.
-            yield util.YES
-            return
-
-        elts = collections.deque(rhs.elts[:])
-        if len(lhs.elts) > len(rhs.elts):
-            # a, *b, c = (1, 2)
-            raise exceptions.InferenceError()
-
-        # Unpack iteratively the values from the rhs of the assignment,
-        # until the find the starred node. What will remain will
-        # be the list of values which the Starred node will represent
-        # This is done in two steps, from left to right to remove
-        # anything before the starred node and from right to left
-        # to remvoe anything after the starred node.
-
-        for index, node in enumerate(lhs.elts):
-            if not isinstance(node, nodes.Starred):
-                elts.popleft()
-                continue
-            lhs_elts = collections.deque(reversed(lhs.elts[index:]))
-            for node in lhs_elts:
-                if not isinstance(node, nodes.Starred):
-                    elts.pop()
-                    continue
-                # We're done
-                packed = nodes.List()
-                packed.elts = elts
-                packed.parent = self
-                yield packed
-                break
-
-nodes.Starred.assigned_stmts = starred_assigned_stmts