libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -24,40 +24,54 @@ on all nodes :
  .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, Function or Class)
+  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 From and Import :
+on ImportFrom and Import :
  .real_name(name),
 
 
 """
-# pylint: disable=unused-import
+# 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,
+)
 
-__docformat__ = "restructuredtext en"
 
-from astroid.node_classes import Arguments, AssAttr, Assert, Assign, \
-    AssName, AugAssign, Backquote, BinOp, BoolOp, Break, CallFunc, Compare, \
-    Comprehension, Const, Continue, Decorators, DelAttr, DelName, Delete, \
-    Dict, Discard, Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice, For, \
-    From, Getattr, 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
-from astroid.scoped_nodes import Module, GenExpr, Lambda, DictComp, \
-    ListComp, SetComp, Function, Class
 
 ALL_NODE_CLASSES = (
-    Arguments, AssAttr, Assert, Assign, AssName, AugAssign,
-    Backquote, BinOp, BoolOp, Break,
-    CallFunc, Class, Compare, Comprehension, Const, Continue,
+    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, Discard,
+    Dict, DictComp, DictUnpack, Expr,
     Ellipsis, EmptyNode, ExceptHandler, Exec, ExtSlice,
-    For, From, Function,
-    Getattr, GenExpr, Global,
+    For, ImportFrom, FunctionDef,
+    Attribute, GeneratorExp, Global,
     If, IfExp, Import, Index,
     Keyword,
     Lambda, List, ListComp,
@@ -69,6 +83,5 @@ ALL_NODE_CLASSES = (
     TryExcept, TryFinally, Tuple,
     UnaryOp,
     While, With,
-    Yield, YieldFrom
+    Yield, YieldFrom,
     )
-

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

@@ -0,0 +1,186 @@
+# 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

@@ -19,28 +19,31 @@
 where it makes sense.
 """
 
-__doctype__ = "restructuredtext en"
 import collections
-
-from astroid.exceptions import InferenceError, NoDefault, NotFoundError
-from astroid.node_classes import unpack_infer
-from astroid.bases import InferenceContext, copy_context, \
-     raise_if_nothing_infered, yes_if_nothing_infered, Instance, YES
-from astroid.nodes import const_factory
+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__',
-                 '**': '__power__',
+                 '**': '__pow__',
                  '%':  '__mod__',
                  '&':  '__and__',
                  '|':  '__or__',
                  '^':  '__xor__',
                  '<<': '__lshift__',
                  '>>': '__rshift__',
+                 '@': '__matmul__'
                 }
 
 UNARY_OP_METHOD = {'+': '__pos__',
@@ -53,7 +56,7 @@ UNARY_OP_METHOD = {'+': '__pos__',
 
 def tl_infer_unary_op(self, operator):
     if operator == 'not':
-        return const_factory(not bool(self.elts))
+        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
@@ -61,19 +64,19 @@ nodes.List.infer_unary_op = tl_infer_unary_op
 
 def dict_infer_unary_op(self, operator):
     if operator == 'not':
-        return const_factory(not bool(self.items))
+        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 const_factory(not self.value)
+        return node_classes.const_factory(not self.value)
     # XXX log potentially raised TypeError
     elif operator == '+':
-        return const_factory(+self.value)
+        return node_classes.const_factory(+self.value)
     else: # operator == '-':
-        return const_factory(-self.value)
+        return node_classes.const_factory(-self.value)
 nodes.Const.infer_unary_op = const_infer_unary_op
 
 
@@ -92,17 +95,23 @@ BIN_OP_IMPL = {'+':  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, operator, other, context):
+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 const_factory(impl(self.value, other.value))
+                    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
@@ -110,68 +119,88 @@ def const_infer_binary_op(self, operator, other, context):
             except TypeError:
                 # XXX log TypeError
                 continue
-        elif other is YES:
+        elif other is util.YES:
             yield other
         else:
             try:
-                for val in other.infer_binary_op(operator, self, context):
+                for val in other.infer_binary_op(binop, self, context):
                     yield val
             except AttributeError:
-                yield YES
-nodes.Const.infer_binary_op = yes_if_nothing_infered(const_infer_binary_op)
+                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 tl_infer_binary_op(self, operator, other, context):
+
+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__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES]
-            elts += [n for elt in other.elts for n in elt.infer(context)
-                     if not n is YES]
+            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 YES
+                yield util.YES
                 continue
-            node = self.__class__()
-            elts = [n for elt in self.elts for n in elt.infer(context)
-                    if not n is YES] * other.value
-            node.elts = elts
-            yield node
-        elif isinstance(other, Instance) and not isinstance(other, nodes.Const):
-            yield YES
+            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 = yes_if_nothing_infered(tl_infer_binary_op)
-nodes.List.infer_binary_op = yes_if_nothing_infered(tl_infer_binary_op)
+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, operator, other, context):
+def dict_infer_binary_op(self, binop, other, context):
     for other in other.infer(context):
-        if isinstance(other, Instance) and isinstance(other._proxied, nodes.Class):
-            yield YES
+        if isinstance(other, bases.Instance) and isinstance(other._proxied, nodes.ClassDef):
+            yield util.YES
         # XXX else log TypeError
-nodes.Dict.infer_binary_op = yes_if_nothing_infered(dict_infer_binary_op)
+nodes.Dict.infer_binary_op = bases.yes_if_nothing_inferred(dict_infer_binary_op)
 
-def instance_infer_binary_op(self, operator, other, context):
+def instance_infer_binary_op(self, binop, other, context):
+    operator = binop.op
     try:
         methods = self.getattr(BIN_OP_METHOD[operator])
-    except (NotFoundError, KeyError):
+    except (exceptions.NotFoundError, KeyError):
         # Unknown operator
-        yield YES
+        yield util.YES
     else:
         for method in methods:
-            if not isinstance(method, nodes.Function):
+            if not isinstance(method, nodes.FunctionDef):
                 continue
             for result in method.infer_call_result(self, context):
-                if result is not YES:
+                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
 
-Instance.infer_binary_op = yes_if_nothing_infered(instance_infer_binary_op)
+bases.Instance.infer_binary_op = bases.yes_if_nothing_inferred(instance_infer_binary_op)
 
 
 # assignment ##################################################################
@@ -192,7 +221,7 @@ def _resolve_looppart(parts, asspath, context):
     asspath = asspath[:]
     index = asspath.pop(0)
     for part in parts:
-        if part is YES:
+        if part is util.YES:
             continue
         # XXX handle __iter__ and log potentially detected errors
         if not hasattr(part, 'itered'):
@@ -212,104 +241,125 @@ def _resolve_looppart(parts, asspath, context):
                 # we achieved to resolved the assignment path,
                 # don't infer the last part
                 yield assigned
-            elif assigned is YES:
+            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 infered in _resolve_looppart(assigned.infer(context),
+                    for inferred in _resolve_looppart(assigned.infer(context),
                                                      asspath, context):
-                        yield infered
-                except InferenceError:
+                        yield inferred
+                except exceptions.InferenceError:
                     break
 
 
-def for_assigned_stmts(self, node, context=None, asspath=None):
+@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 infered in _resolve_looppart(self.iter.infer(context),
+        for inferred in _resolve_looppart(self.iter.infer(context),
                                          asspath, context):
-            yield infered
+            yield inferred
 
-nodes.For.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
-nodes.Comprehension.assigned_stmts = raise_if_nothing_infered(for_assigned_stmts)
+nodes.For.assigned_stmts = for_assigned_stmts
+nodes.Comprehension.assigned_stmts = for_assigned_stmts
 
 
-def mulass_assigned_stmts(self, node, context=None, asspath=None):
+def sequence_assigned_stmts(self, node=None, context=None, asspath=None):
     if asspath is None:
         asspath = []
-    asspath.insert(0, self.elts.index(node))
-    return self.parent.assigned_stmts(self, context, asspath)
-nodes.Tuple.assigned_stmts = mulass_assigned_stmts
-nodes.List.assigned_stmts = mulass_assigned_stmts
+    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, context=None):
-    return self.parent.assigned_stmts(self, context=context)
-nodes.AssName.assigned_stmts = assend_assigned_stmts
-nodes.AssAttr.assigned_stmts = assend_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 YES
+        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 Instance(self.parent.parent.frame())
+            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 = const_factory(())
+        vararg = node_classes.const_factory(())
         vararg.parent = self
         yield vararg
         return
     if name == self.kwarg:
-        kwarg = const_factory({})
+        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 = copy_context(context)
-        for infered in self.default_value(name).infer(context):
-            yield infered
-        yield YES
-    except NoDefault:
-        yield YES
+        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, context, asspath=None):
+def arguments_assigned_stmts(self, node=None, context=None, asspath=None):
     if context.callcontext:
         # reset call context/name
         callcontext = context.callcontext
-        context = copy_context(context)
+        context = contextmod.copy_context(context)
         context.callcontext = None
-        return callcontext.infer_argument(self.parent, node.name, context)
+        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
 
 
-def assign_assigned_stmts(self, node, context=None, asspath=None):
+@bases.raise_if_nothing_inferred
+def assign_assigned_stmts(self, node=None, context=None, asspath=None):
     if not asspath:
         yield self.value
         return
-    for infered in _resolve_asspart(self.value.infer(context), asspath, context):
-        yield infered
-nodes.Assign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
-nodes.AugAssign.assigned_stmts = raise_if_nothing_infered(assign_assigned_stmts)
+    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):
@@ -328,28 +378,30 @@ def _resolve_asspart(parts, asspath, context):
                 # we achieved to resolved the assignment path, don't infer the
                 # last part
                 yield assigned
-            elif assigned is YES:
+            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 infered in _resolve_asspart(assigned.infer(context),
+                    for inferred in _resolve_asspart(assigned.infer(context),
                                                     asspath, context):
-                        yield infered
-                except InferenceError:
+                        yield inferred
+                except exceptions.InferenceError:
                     return
 
 
-def excepthandler_assigned_stmts(self, node, context=None, asspath=None):
-    for assigned in unpack_infer(self.type):
-        if isinstance(assigned, nodes.Class):
-            assigned = Instance(assigned)
+@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 = raise_if_nothing_infered(excepthandler_assigned_stmts)
+nodes.ExceptHandler.assigned_stmts = bases.raise_if_nothing_inferred(excepthandler_assigned_stmts)
 
 
-def with_assigned_stmts(self, node, context=None, asspath=None):
+@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:
@@ -358,13 +410,14 @@ def with_assigned_stmts(self, node, context=None, asspath=None):
                 if isinstance(lst, (nodes.Tuple, nodes.List)):
                     for item in lst.nodes:
                         yield item
-nodes.With.assigned_stmts = raise_if_nothing_infered(with_assigned_stmts)
+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 InferenceError()
+        raise exceptions.InferenceError()
 
     if isinstance(stmt, nodes.Assign):
         value = stmt.value
@@ -372,24 +425,24 @@ def starred_assigned_stmts(self, node=None, context=None, asspath=None):
 
         if sum(1 for node in lhs.nodes_of_class(nodes.Starred)) > 1:
             # Too many starred arguments in the expression.
-            raise InferenceError()
+            raise exceptions.InferenceError()
 
         if context is None:
-            context = InferenceContext()
+            context = contextmod.InferenceContext()
         try:
             rhs = next(value.infer(context))
-        except InferenceError:
-            yield YES
+        except exceptions.InferenceError:
+            yield util.YES
             return
-        if rhs is YES or not hasattr(rhs, 'elts'):
+        if rhs is util.YES or not hasattr(rhs, 'elts'):
             # Not interested in inferred values without elts.
-            yield YES
+            yield util.YES
             return
 
         elts = collections.deque(rhs.elts[:])
         if len(lhs.elts) > len(rhs.elts):
             # a, *b, c = (1, 2)
-            raise InferenceError()
+            raise exceptions.InferenceError()
 
         # Unpack iteratively the values from the rhs of the assignment,
         # until the find the starred node. What will remain will
@@ -408,8 +461,10 @@ def starred_assigned_stmts(self, node=None, context=None, asspath=None):
                     elts.pop()
                     continue
                 # We're done
-                for elt in elts:
-                    yield elt
+                packed = nodes.List()
+                packed.elts = elts
+                packed.parent = self
+                yield packed
                 break
 
 nodes.Starred.assigned_stmts = starred_assigned_stmts