libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -30,6 +30,26 @@ class AstroidBuildingException(AstroidError):
 class ResolveError(AstroidError):
     """base class of astroid resolution/inference error"""
 
+class MroError(ResolveError):
+    """Error raised when there is a problem with method resolution of a class."""
+
+
+class DuplicateBasesError(MroError):
+    """Error raised when there are duplicate bases in the same class bases."""
+
+
+class InconsistentMroError(MroError):
+    """Error raised when a class's MRO is inconsistent."""
+
+
+class SuperError(ResolveError):
+    """Error raised when there is a problem with a super call."""
+
+
+class SuperArgumentTypeError(SuperError):
+    """Error raised when the super arguments are invalid."""
+
+
 class NotFoundError(ResolveError):
     """raised when we are unable to resolve a name"""
 

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

@@ -18,125 +18,32 @@
 """this module contains a set of functions to handle inference on astroid trees
 """
 
-__doctype__ = "restructuredtext en"
-
-from itertools import chain
+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
 
-from astroid.manager import AstroidManager
-from astroid.exceptions import (AstroidError, InferenceError, NoDefault,
-                                NotFoundError, UnresolvableName)
-from astroid.bases import (YES, Instance, InferenceContext,
-                           _infer_stmts, copy_context, path_wrapper,
-                           raise_if_nothing_infered)
-from astroid.protocols import (
-    _arguments_infer_argname,
-    BIN_OP_METHOD, UNARY_OP_METHOD)
-
-MANAGER = AstroidManager()
-
-
-class CallContext(object):
-    """when inferring a function call, this class is used to remember values
-    given as argument
-    """
-    def __init__(self, args, starargs, dstarargs):
-        self.args = []
-        self.nargs = {}
-        for arg in args:
-            if isinstance(arg, nodes.Keyword):
-                self.nargs[arg.arg] = arg.value
-            else:
-                self.args.append(arg)
-        self.starargs = starargs
-        self.dstarargs = dstarargs
 
-    def infer_argument(self, funcnode, name, context):
-        """infer a function argument value according to the call context"""
-        # 1. search in named keywords
-        try:
-            return self.nargs[name].infer(context)
-        except KeyError:
-            # Function.args.args can be None in astroid (means that we don't have
-            # information on argnames)
-            argindex = funcnode.args.find_argname(name)[0]
-            if argindex is not None:
-                # 2. first argument of instance/class method
-                if argindex == 0 and funcnode.type in ('method', 'classmethod'):
-                    if context.boundnode is not None:
-                        boundnode = context.boundnode
-                    else:
-                        # XXX can do better ?
-                        boundnode = funcnode.parent.frame()
-                    if funcnode.type == 'method':
-                        if not isinstance(boundnode, Instance):
-                            boundnode = Instance(boundnode)
-                        return iter((boundnode,))
-                    if funcnode.type == 'classmethod':
-                        return iter((boundnode,))
-                # if we have a method, extract one position
-                # from the index, so we'll take in account
-                # the extra parameter represented by `self` or `cls`
-                if funcnode.type in ('method', 'classmethod'):
-                    argindex -= 1
-                # 2. search arg index
-                try:
-                    return self.args[argindex].infer(context)
-                except IndexError:
-                    pass
-                # 3. search in *args (.starargs)
-                if self.starargs is not None:
-                    its = []
-                    for infered in self.starargs.infer(context):
-                        if infered is YES:
-                            its.append((YES,))
-                            continue
-                        try:
-                            its.append(infered.getitem(argindex, context).infer(context))
-                        except (InferenceError, AttributeError):
-                            its.append((YES,))
-                        except (IndexError, TypeError):
-                            continue
-                    if its:
-                        return chain(*its)
-        # 4. XXX search in **kwargs (.dstarargs)
-        if self.dstarargs is not None:
-            its = []
-            for infered in self.dstarargs.infer(context):
-                if infered is YES:
-                    its.append((YES,))
-                    continue
-                try:
-                    its.append(infered.getitem(name, context).infer(context))
-                except (InferenceError, AttributeError):
-                    its.append((YES,))
-                except (IndexError, TypeError):
-                    continue
-            if its:
-                return chain(*its)
-        # 5. */** argument, (Tuple or Dict)
-        if name == funcnode.args.vararg:
-            return iter((nodes.const_factory(())))
-        if name == funcnode.args.kwarg:
-            return iter((nodes.const_factory({})))
-        # 6. return default value if any
-        try:
-            return funcnode.args.default_value(name).infer(context)
-        except NoDefault:
-            raise InferenceError(name)
+MANAGER = manager.AstroidManager()
 
 
 # .infer method ###############################################################
 
 
 def infer_end(self, context=None):
-    """inference's end for node such as Module, Class, Function, Const...
+    """inference's end for node such as Module, ClassDef, FunctionDef,
+    Const...
+
     """
     yield self
 nodes.Module._infer = infer_end
-nodes.Class._infer = infer_end
-nodes.Function._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
@@ -157,7 +64,7 @@ def _higher_function_scope(node):
         which encloses the given node.
     """
     current = node
-    while current.parent and not isinstance(current.parent, nodes.Function):
+    while current.parent and not isinstance(current.parent, nodes.FunctionDef):
         current = current.parent
     if current and current.parent:
         return current.parent
@@ -174,72 +81,80 @@ def infer_name(self, context=None):
             _, stmts = parent_function.lookup(self.name)
 
         if not stmts:
-            raise UnresolvableName(self.name)
+            raise exceptions.UnresolvableName(self.name)
     context = context.clone()
     context.lookupname = self.name
-    return _infer_stmts(stmts, context, frame)
-nodes.Name._infer = path_wrapper(infer_name)
-nodes.AssName.infer_lhs = infer_name # won't work with a path wrapper
+    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
 
 
-def infer_callfunc(self, context=None):
-    """infer a CallFunc node by trying to guess what the function returns"""
+@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 = CallContext(self.args, self.starargs, self.kwargs)
+    callcontext.callcontext = contextmod.CallContext(args=self.args,
+                                                     keywords=self.keywords)
     callcontext.boundnode = None
     for callee in self.func.infer(context):
-        if callee is YES:
+        if callee is util.YES:
             yield callee
             continue
         try:
             if hasattr(callee, 'infer_call_result'):
-                for infered in callee.infer_call_result(self, callcontext):
-                    yield infered
-        except InferenceError:
+                for inferred in callee.infer_call_result(self, callcontext):
+                    yield inferred
+        except exceptions.InferenceError:
             ## XXX log error ?
             continue
-nodes.CallFunc._infer = path_wrapper(raise_if_nothing_infered(infer_callfunc))
+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 InferenceError()
+        raise exceptions.InferenceError()
     if asname:
         yield self.do_import_module(self.real_name(name))
     else:
         yield self.do_import_module(name)
-nodes.Import._infer = path_wrapper(infer_import)
+nodes.Import._infer = infer_import
+
 
 def infer_name_module(self, name):
-    context = InferenceContext()
+    context = contextmod.InferenceContext()
     context.lookupname = name
     return self.infer(context, asname=False)
 nodes.Import.infer_name_module = infer_name_module
 
 
-def infer_from(self, context=None, asname=True):
-    """infer a From nodes: return the imported module/object"""
+@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 InferenceError()
+        raise exceptions.InferenceError()
     if asname:
         name = self.real_name(name)
     module = self.do_import_module()
     try:
-        context = copy_context(context)
+        context = contextmod.copy_context(context)
         context.lookupname = name
-        return _infer_stmts(module.getattr(name, ignore_locals=module is self.root()), context)
-    except NotFoundError:
-        raise InferenceError(name)
-nodes.From._infer = path_wrapper(infer_from)
+        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
 
 
-def infer_getattr(self, context=None):
-    """infer a Getattr node by using getattr on the associated object"""
+@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 YES:
+        if owner is util.YES:
             yield owner
             continue
         try:
@@ -247,58 +162,69 @@ def infer_getattr(self, context=None):
             for obj in owner.igetattr(self.attrname, context):
                 yield obj
             context.boundnode = None
-        except (NotFoundError, InferenceError):
+        except (exceptions.NotFoundError, exceptions.InferenceError):
             context.boundnode = None
         except AttributeError:
             # XXX method / function
             context.boundnode = None
-nodes.Getattr._infer = path_wrapper(raise_if_nothing_infered(infer_getattr))
-nodes.AssAttr.infer_lhs = raise_if_nothing_infered(infer_getattr) # # won't work with a path wrapper
+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 InferenceError()
+        raise exceptions.InferenceError()
     try:
-        return _infer_stmts(self.root().getattr(context.lookupname), context)
-    except NotFoundError:
-        raise InferenceError()
-nodes.Global._infer = path_wrapper(infer_global)
+        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):
-    """infer simple subscription such as [1,2,3][0] or (1,2,3)[-1]"""
+    """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 YES:
-        yield YES
+    if value is util.YES:
+        yield util.YES
         return
 
     index = next(self.slice.infer(context))
-    if index is YES:
-        yield YES
+    if index is util.YES:
+        yield util.YES
         return
 
     if isinstance(index, nodes.Const):
         try:
             assigned = value.getitem(index.value, context)
         except AttributeError:
-            raise InferenceError()
+            raise exceptions.InferenceError()
         except (IndexError, TypeError):
-            yield YES
+            yield util.YES
             return
 
         # Prevent inferring if the infered subscript
         # is the same as the original subscripted object.
-        if self is assigned:
-            yield YES
+        if self is assigned or assigned is util.YES:
+            yield util.YES
             return
         for infered in assigned.infer(context):
             yield infered
     else:
-        raise InferenceError()
-nodes.Subscript._infer = path_wrapper(infer_subscript)
-nodes.Subscript.infer_lhs = raise_if_nothing_infered(infer_subscript)
+        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:
@@ -306,9 +232,9 @@ def infer_unaryop(self, context=None):
         except TypeError:
             continue
         except AttributeError:
-            meth = UNARY_OP_METHOD[self.op]
+            meth = protocols.UNARY_OP_METHOD[self.op]
             if meth is None:
-                yield YES
+                yield util.YES
             else:
                 try:
                     # XXX just suppose if the type implement meth, returned type
@@ -318,88 +244,116 @@ def infer_unaryop(self, context=None):
                 except GeneratorExit:
                     raise
                 except:
-                    yield YES
-nodes.UnaryOp._infer = path_wrapper(infer_unaryop)
+                    yield util.YES
+nodes.UnaryOp._infer = bases.path_wrapper(infer_unaryop)
 
-def _infer_binop(operator, operand1, operand2, context, failures=None):
-    if operand1 is YES:
+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(operator, operand2, context):
+        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(BIN_OP_METHOD[operator])
+            operand1.getattr(protocols.BIN_OP_METHOD[operator])
             yield operand1
         except:
             if failures is None:
-                yield YES
+                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.op, lhs, self.right, context, failures):
+        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.op, rhs, lhs, context):
+            for val in _infer_binop(self, rhs, lhs, context):
                 yield val
-nodes.BinOp._infer = path_wrapper(infer_binop)
+nodes.BinOp._infer = bases.path_wrapper(infer_binop)
 
 
 def infer_arguments(self, context=None):
     name = context.lookupname
     if name is None:
-        raise InferenceError()
-    return _arguments_infer_argname(self, name, context)
+        raise exceptions.InferenceError()
+    return protocols._arguments_infer_argname(self, name, context)
 nodes.Arguments._infer = infer_arguments
 
 
-def infer_ass(self, context=None):
-    """infer a AssName/AssAttr: need to inspect the RHS part of the
+@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 _infer_stmts(stmts, context)
-nodes.AssName._infer = path_wrapper(infer_ass)
-nodes.AssAttr._infer = path_wrapper(infer_ass)
+    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.op, lhs, self.value, context, failures):
+        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.op, rhs, lhs, context):
+            for val in _infer_binop(self, rhs, lhs, context):
                 yield val
-nodes.AugAssign._infer = path_wrapper(infer_augassign)
+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 YES
+        yield util.YES
     else:
         try:
-            for infered in MANAGER.infer_ast_from_something(self.object,
-                                                            context=context):
-                yield infered
-        except AstroidError:
-            yield YES
-nodes.EmptyNode._infer = path_wrapper(infer_empty_node)
+            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