libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/logilab/astroid/brain/{builtin_inference.py → brain_builtin_inference.py}

@@ -7,9 +7,11 @@ from textwrap import dedent
 import six
 from astroid import (MANAGER, UseInferenceDefault,
                      inference_tip, YES, InferenceError, UnresolvableName)
+from astroid import arguments
 from astroid import nodes
+from astroid import objects
 from astroid.builder import AstroidBuilder
-
+from astroid import util
 
 def _extend_str(class_node, rvalue):
     """function to extend builtin str/unicode class"""
@@ -51,7 +53,7 @@ def _extend_str(class_node, rvalue):
         def rstrip(self, chars=None):
             return {rvalue}
         def rjust(self, width, fillchar=None):
-            return {rvalue} 
+            return {rvalue}
         def center(self, width, fillchar=None):
             return {rvalue}
         def ljust(self, width, fillchar=None):
@@ -60,7 +62,7 @@ def _extend_str(class_node, rvalue):
     code = code.format(rvalue=rvalue)
     fake = AstroidBuilder(MANAGER).string_build(code)['whatever']
     for method in fake.mymethods():
-        class_node.locals[method.name] = [method]
+        class_node._locals[method.name] = [method]
         method.parent = class_node
 
 def extend_builtins(class_transforms):
@@ -86,12 +88,17 @@ def register_builtin_transform(transform, builtin_name):
     def _transform_wrapper(node, context=None):
         result = transform(node, context=context)
         if result:
-            result.parent = node
+            if not result.parent:
+                # Let the transformation function determine
+                # the parent for its result. Otherwise,
+                # we set it to be the node we transformed from.
+                result.parent = node
+
             result.lineno = node.lineno
             result.col_offset = node.col_offset
         return iter([result])
 
-    MANAGER.register_transform(nodes.CallFunc,
+    MANAGER.register_transform(nodes.Call,
                                inference_tip(_transform_wrapper),
                                lambda n: (isinstance(n.func, nodes.Name) and
                                           n.func.name == builtin_name))
@@ -108,13 +115,13 @@ def _generic_inference(node, context, node_type, transform):
     transformed = transform(arg)
     if not transformed:
         try:
-            infered = next(arg.infer(context=context))
+            inferred = next(arg.infer(context=context))
         except (InferenceError, StopIteration):
             raise UseInferenceDefault()
-        if infered is YES:
+        if inferred is util.YES:
             raise UseInferenceDefault()
-        transformed = transform(infered)
-    if not transformed or transformed is YES:
+        transformed = transform(inferred)
+    if not transformed or transformed is util.YES:
         raise UseInferenceDefault()
     return transformed
 
@@ -172,19 +179,25 @@ infer_set = partial(
     iterables=(nodes.List, nodes.Tuple),
     build_elts=set)
 
+infer_frozenset = partial(
+    _infer_builtin,
+    klass=objects.FrozenSet,
+    iterables=(nodes.List, nodes.Tuple, nodes.Set),
+    build_elts=frozenset)
+
 
 def _get_elts(arg, context):
     is_iterable = lambda n: isinstance(n,
                                        (nodes.List, nodes.Tuple, nodes.Set))
     try:
-        infered = next(arg.infer(context))
+        inferred = next(arg.infer(context))
     except (InferenceError, UnresolvableName):
         raise UseInferenceDefault()
-    if isinstance(infered, nodes.Dict):
-        items = infered.items
-    elif is_iterable(infered):
+    if isinstance(inferred, nodes.Dict):
+        items = inferred.items
+    elif is_iterable(inferred):
         items = []
-        for elt in infered.elts:
+        for elt in inferred.elts:
             # If an item is not a pair of two items,
             # then fallback to the default inference.
             # Also, take in consideration only hashable items,
@@ -213,24 +226,28 @@ def infer_dict(node, context=None):
         * dict(mapping, **kwargs)
         * dict(**kwargs)
 
-    If a case can't be infered, we'll fallback to default inference.
+    If a case can't be inferred, we'll fallback to default inference.
     """
-    has_keywords = lambda args: all(isinstance(arg, nodes.Keyword)
-                                    for arg in args)
-    if not node.args and not node.kwargs:
+    call = arguments.CallSite.from_call(node)
+    if call.has_invalid_arguments() or call.has_invalid_keywords():
+        raise UseInferenceDefault
+
+    args = call.positional_arguments
+    kwargs = list(call.keyword_arguments.items())
+
+    if not args and not kwargs:
         # dict()
         return nodes.Dict()
-    elif has_keywords(node.args) and node.args:
+    elif kwargs and not args:
         # dict(a=1, b=2, c=4)
-        items = [(nodes.Const(arg.arg), arg.value) for arg in node.args]
-    elif (len(node.args) >= 2 and
-          has_keywords(node.args[1:])):
+        items = [(nodes.Const(key), value) for key, value in kwargs]
+    elif len(args) == 1 and kwargs:
         # dict(some_iterable, b=2, c=4)
-        elts = _get_elts(node.args[0], context)
-        keys = [(nodes.Const(arg.arg), arg.value) for arg in node.args[1:]]
+        elts = _get_elts(args[0], context)
+        keys = [(nodes.Const(key), value) for key, value in kwargs]
         items = elts + keys
-    elif len(node.args) == 1:
-        items = _get_elts(node.args[0], context)
+    elif len(args) == 1:
+        items = _get_elts(args[0], context)
     else:
         raise UseInferenceDefault()
 
@@ -238,8 +255,82 @@ def infer_dict(node, context=None):
     empty.items = items
     return empty
 
+
+def _node_class(node):
+    klass = node.frame()
+    while klass is not None and not isinstance(klass, nodes.ClassDef):
+        if klass.parent is None:
+            klass = None
+        else:
+            klass = klass.parent.frame()
+    return klass
+
+
+def infer_super(node, context=None):
+    """Understand super calls.
+
+    There are some restrictions for what can be understood:
+
+        * unbounded super (one argument form) is not understood.
+
+        * if the super call is not inside a function (classmethod or method),
+          then the default inference will be used.
+
+        * if the super arguments can't be infered, the default inference
+          will be used.
+    """
+    if len(node.args) == 1:
+        # Ignore unbounded super.
+        raise UseInferenceDefault
+
+    scope = node.scope()
+    if not isinstance(scope, nodes.FunctionDef):
+        # Ignore non-method uses of super.
+        raise UseInferenceDefault
+    if scope.type not in ('classmethod', 'method'):
+        # Not interested in staticmethods.
+        raise UseInferenceDefault
+
+    cls = _node_class(scope)
+    if not len(node.args):
+        mro_pointer = cls
+        # In we are in a classmethod, the interpreter will fill
+        # automatically the class as the second argument, not an instance.
+        if scope.type == 'classmethod':
+            mro_type = cls
+        else:
+            mro_type = cls.instantiate_class()
+    else:
+        # TODO(cpopa): support flow control (multiple inference values).
+        try:
+            mro_pointer = next(node.args[0].infer(context=context))
+        except InferenceError:
+            raise UseInferenceDefault
+        try:
+            mro_type = next(node.args[1].infer(context=context))
+        except InferenceError:
+            raise UseInferenceDefault
+
+    if mro_pointer is YES or mro_type is YES:
+        # No way we could understand this.
+        raise UseInferenceDefault
+
+    super_obj = objects.Super(mro_pointer=mro_pointer,
+                              mro_type=mro_type,
+                              self_class=cls,
+                              scope=scope)
+    super_obj.parent = node
+    return iter([super_obj])
+
+
 # Builtins inference
+MANAGER.register_transform(nodes.Call,
+                           inference_tip(infer_super),
+                           lambda n: (isinstance(n.func, nodes.Name) and
+                                      n.func.name == 'super'))
+
 register_builtin_transform(infer_tuple, 'tuple')
 register_builtin_transform(infer_set, 'set')
 register_builtin_transform(infer_list, 'list')
 register_builtin_transform(infer_dict, 'dict')
+register_builtin_transform(infer_frozenset, 'frozenset')

data/vendor/depot_tools/third_party/logilab/astroid/brain/brain_dateutil.py

@@ -0,0 +1,15 @@
+"""Astroid hooks for dateutil"""
+
+import textwrap
+
+from astroid import MANAGER, register_module_extender
+from astroid.builder import AstroidBuilder
+
+def dateutil_transform():
+    return AstroidBuilder(MANAGER).string_build(textwrap.dedent('''
+    import datetime
+    def parse(timestr, parserinfo=None, **kwargs):
+        return datetime.datetime()
+    '''))
+
+register_module_extender(MANAGER, 'dateutil.parser', dateutil_transform)

data/vendor/depot_tools/third_party/logilab/astroid/brain/{py2gi.py → brain_gi.py}

@@ -7,8 +7,9 @@ import inspect
 import itertools
 import sys
 import re
+import warnings
 
-from astroid import MANAGER, AstroidBuildingException
+from astroid import MANAGER, AstroidBuildingException, nodes
 from astroid.builder import AstroidBuilder
 
 
@@ -46,13 +47,13 @@ def _gi_build_stub(parent):
         elif (inspect.ismethod(obj) or
               inspect.ismethoddescriptor(obj)):
             methods[name] = obj
-        elif type(obj) in [int, str]:
-            constants[name] = obj
         elif (str(obj).startswith("<flags") or
               str(obj).startswith("<enum ") or
               str(obj).startswith("<GType ") or
               inspect.isdatadescriptor(obj)):
             constants[name] = 0
+        elif isinstance(obj, (int, str)):
+            constants[name] = obj
         elif callable(obj):
             # Fall back to a function for anything callable
             functions[name] = obj
@@ -73,7 +74,7 @@ def _gi_build_stub(parent):
         val = constants[name]
 
         strval = str(val)
-        if type(val) is str:
+        if isinstance(val, str):
             strval = '"%s"' % str(val).replace("\\", "\\\\")
         ret += "%s = %s\n" % (name, strval)
 
@@ -82,7 +83,6 @@ def _gi_build_stub(parent):
     if functions:
         ret += "# %s functions\n\n" % parent.__name__
     for name in sorted(functions):
-        func = functions[name]
         ret += "def %s(*args, **kwargs):\n" % name
         ret += "    pass\n"
 
@@ -91,7 +91,6 @@ def _gi_build_stub(parent):
     if methods:
         ret += "# %s methods\n\n" % parent.__name__
     for name in sorted(methods):
-        func = methods[name]
         ret += "def %s(self, *args, **kwargs):\n" % name
         ret += "    pass\n"
 
@@ -135,7 +134,16 @@ def _import_gi_module(modname):
             for m in itertools.chain(modnames, optional_modnames):
                 try:
                     __import__(m)
-                    modcode += _gi_build_stub(sys.modules[m])
+                    with warnings.catch_warnings():
+                        # Just inspecting the code can raise gi deprecation
+                        # warnings, so ignore them.
+                        try:
+                            from gi import PyGIDeprecationWarning
+                            warnings.simplefilter("ignore", PyGIDeprecationWarning)
+                        except Exception:
+                            pass
+
+                        modcode += _gi_build_stub(sys.modules[m])
                 except ImportError:
                     if m not in optional_modnames:
                         raise
@@ -150,6 +158,38 @@ def _import_gi_module(modname):
         raise AstroidBuildingException('Failed to import module %r' % modname)
     return astng
 
+def _looks_like_require_version(node):
+    # Return whether this looks like a call to gi.require_version(<name>, <version>)
+    # Only accept function calls with two constant arguments
+    if len(node.args) != 2:
+        return False
 
-MANAGER.register_failed_import_hook(_import_gi_module)
+    if not all(isinstance(arg, nodes.Const) for arg in node.args):
+        return False
+
+    func = node.func
+    if isinstance(func, nodes.Attribute):
+        if func.attrname != 'require_version':
+            return False
+        if isinstance(func.expr, nodes.Name) and func.expr.name == 'gi':
+            return True
+
+        return False
 
+    if isinstance(func, nodes.Name):
+        return func.name == 'require_version'
+
+    return False
+
+def _register_require_version(node):
+    # Load the gi.require_version locally
+    try:
+        import gi
+        gi.require_version(node.args[0].value, node.args[1].value)
+    except Exception:
+        pass
+
+    return node
+
+MANAGER.register_failed_import_hook(_import_gi_module)
+MANAGER.register_transform(nodes.Call, _register_require_version, _looks_like_require_version)

data/vendor/depot_tools/third_party/logilab/astroid/brain/{pynose.py → brain_nose.py}

@@ -48,11 +48,14 @@ def _nose_tools_functions():
         if method.name.startswith('assert') and '_' not in method.name:
             pep8_name = _pep8(method.name)
             yield pep8_name, astroid.BoundMethod(method, case)
+        if method.name == 'assertEqual':
+            # nose also exports assert_equals.
+            yield 'assert_equals', astroid.BoundMethod(method, case)
 
 
 def _nose_tools_transform(node):
     for method_name, method in _nose_tools_functions():
-        node.locals[method_name] = [method]
+        node._locals[method_name] = [method]
 
 
 def _nose_tools_trivial_transform():

data/vendor/depot_tools/third_party/logilab/astroid/brain/brain_numpy.py

@@ -0,0 +1,62 @@
+# 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/>.
+
+"""Astroid hooks for numpy."""
+
+import astroid
+
+
+# TODO(cpopa): drop when understanding augmented assignments
+
+def numpy_core_transform():
+    return astroid.parse('''
+    from numpy.core import numeric
+    from numpy.core import fromnumeric
+    from numpy.core import defchararray
+    from numpy.core import records
+    from numpy.core import function_base
+    from numpy.core import machar
+    from numpy.core import getlimits
+    from numpy.core import shape_base
+    __all__ = (['char', 'rec', 'memmap', 'chararray'] + numeric.__all__ +
+               fromnumeric.__all__ +
+               records.__all__ +
+               function_base.__all__ +
+               machar.__all__ +
+               getlimits.__all__ +
+               shape_base.__all__)
+    ''')
+
+
+def numpy_transform():
+    return astroid.parse('''
+    from numpy import core
+    from numpy import matrixlib as _mat
+    from numpy import lib
+    __all__ = ['add_newdocs',
+               'ModuleDeprecationWarning',
+               'VisibleDeprecationWarning', 'linalg', 'fft', 'random',
+               'ctypeslib', 'ma',
+               '__version__', 'pkgload', 'PackageLoader',
+               'show_config'] + core.__all__ + _mat.__all__ + lib.__all__
+
+    ''')
+    
+
+astroid.register_module_extender(astroid.MANAGER, 'numpy.core', numpy_core_transform)
+astroid.register_module_extender(astroid.MANAGER, 'numpy', numpy_transform)

data/vendor/depot_tools/third_party/logilab/astroid/brain/brain_pytest.py

@@ -0,0 +1,76 @@
+"""Astroid hooks for pytest."""
+from __future__ import absolute_import
+from astroid import MANAGER, register_module_extender
+from astroid.builder import AstroidBuilder
+
+
+def pytest_transform():
+    return AstroidBuilder(MANAGER).string_build('''
+
+try:
+    import _pytest.mark
+    import _pytest.recwarn
+    import _pytest.runner
+    import _pytest.python
+    import _pytest.skipping
+    import _pytest.assertion
+except ImportError:
+    pass
+else:
+    deprecated_call = _pytest.recwarn.deprecated_call
+    warns = _pytest.recwarn.warns
+
+    exit = _pytest.runner.exit
+    fail = _pytest.runner.fail
+    skip = _pytest.runner.skip
+    importorskip = _pytest.runner.importorskip
+
+    xfail = _pytest.skipping.xfail
+    mark = _pytest.mark.MarkGenerator()
+    raises = _pytest.python.raises
+
+    # New in pytest 3.0
+    try:
+        approx = _pytest.python.approx
+        register_assert_rewrite = _pytest.assertion.register_assert_rewrite
+    except AttributeError:
+        pass
+
+
+# Moved in pytest 3.0
+
+try:
+    import _pytest.freeze_support
+    freeze_includes = _pytest.freeze_support.freeze_includes
+except ImportError:
+    try:
+        import _pytest.genscript
+        freeze_includes = _pytest.genscript.freeze_includes
+    except ImportError:
+        pass
+
+try:
+    import _pytest.debugging
+    set_trace = _pytest.debugging.pytestPDB().set_trace
+except ImportError:
+    try:
+        import _pytest.pdb
+        set_trace = _pytest.pdb.pytestPDB().set_trace
+    except ImportError:
+        pass
+
+try:
+    import _pytest.fixtures
+    fixture = _pytest.fixtures.fixture
+    yield_fixture = _pytest.fixtures.yield_fixture
+except ImportError:
+    try:
+        import _pytest.python
+        fixture = _pytest.python.fixture
+        yield_fixture = _pytest.python.yield_fixture
+    except ImportError:
+        pass
+''')
+
+register_module_extender(MANAGER, 'pytest', pytest_transform)
+register_module_extender(MANAGER, 'py.test', pytest_transform)