libv8 7.3.492.27.1 → 8.4.255.0

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

@@ -1,336 +0,0 @@
-"""Astroid hooks for various builtins."""
-
-import sys
-from functools import partial
-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"""
-    # TODO(cpopa): this approach will make astroid to believe
-    # that some arguments can be passed by keyword, but
-    # unfortunately, strings and bytes don't accept keyword arguments.
-    code = dedent('''
-    class whatever(object):
-        def join(self, iterable):
-            return {rvalue}
-        def replace(self, old, new, count=None):
-            return {rvalue}
-        def format(self, *args, **kwargs):
-            return {rvalue}
-        def encode(self, encoding='ascii', errors=None):
-            return ''
-        def decode(self, encoding='ascii', errors=None):
-            return u''
-        def capitalize(self):
-            return {rvalue}
-        def title(self):
-            return {rvalue}
-        def lower(self):
-            return {rvalue}
-        def upper(self):
-            return {rvalue}
-        def swapcase(self):
-            return {rvalue}
-        def index(self, sub, start=None, end=None):
-            return 0
-        def find(self, sub, start=None, end=None):
-            return 0
-        def count(self, sub, start=None, end=None):
-            return 0
-        def strip(self, chars=None):
-            return {rvalue}
-        def lstrip(self, chars=None):
-            return {rvalue}
-        def rstrip(self, chars=None):
-            return {rvalue}
-        def rjust(self, width, fillchar=None):
-            return {rvalue}
-        def center(self, width, fillchar=None):
-            return {rvalue}
-        def ljust(self, width, fillchar=None):
-            return {rvalue}
-    ''')
-    code = code.format(rvalue=rvalue)
-    fake = AstroidBuilder(MANAGER).string_build(code)['whatever']
-    for method in fake.mymethods():
-        class_node._locals[method.name] = [method]
-        method.parent = class_node
-
-def extend_builtins(class_transforms):
-    from astroid.bases import BUILTINS
-    builtin_ast = MANAGER.astroid_cache[BUILTINS]
-    for class_name, transform in class_transforms.items():
-        transform(builtin_ast[class_name])
-
-if sys.version_info > (3, 0):
-    extend_builtins({'bytes': partial(_extend_str, rvalue="b''"),
-                     'str': partial(_extend_str, rvalue="''")})
-else:
-    extend_builtins({'str': partial(_extend_str, rvalue="''"),
-                     'unicode': partial(_extend_str, rvalue="u''")})
-
-
-def register_builtin_transform(transform, builtin_name):
-    """Register a new transform function for the given *builtin_name*.
-
-    The transform function must accept two parameters, a node and
-    an optional context.
-    """
-    def _transform_wrapper(node, context=None):
-        result = transform(node, context=context)
-        if result:
-            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.Call,
-                               inference_tip(_transform_wrapper),
-                               lambda n: (isinstance(n.func, nodes.Name) and
-                                          n.func.name == builtin_name))
-
-
-def _generic_inference(node, context, node_type, transform):
-    args = node.args
-    if not args:
-        return node_type()
-    if len(node.args) > 1:
-        raise UseInferenceDefault()
-
-    arg, = args
-    transformed = transform(arg)
-    if not transformed:
-        try:
-            inferred = next(arg.infer(context=context))
-        except (InferenceError, StopIteration):
-            raise UseInferenceDefault()
-        if inferred is util.YES:
-            raise UseInferenceDefault()
-        transformed = transform(inferred)
-    if not transformed or transformed is util.YES:
-        raise UseInferenceDefault()
-    return transformed
-
-
-def _generic_transform(arg, klass, iterables, build_elts):
-    if isinstance(arg, klass):
-        return arg
-    elif isinstance(arg, iterables):
-        if not all(isinstance(elt, nodes.Const)
-                   for elt in arg.elts):
-            # TODO(cpopa): Don't support heterogenous elements.
-            # Not yet, though.
-            raise UseInferenceDefault()
-        elts = [elt.value for elt in arg.elts]
-    elif isinstance(arg, nodes.Dict):
-        if not all(isinstance(elt[0], nodes.Const)
-                   for elt in arg.items):
-            raise UseInferenceDefault()
-        elts = [item[0].value for item in arg.items]
-    elif (isinstance(arg, nodes.Const) and
-          isinstance(arg.value, (six.string_types, six.binary_type))):
-        elts = arg.value
-    else:
-        return
-    return klass(elts=build_elts(elts))
-
-
-def _infer_builtin(node, context,
-                   klass=None, iterables=None,
-                   build_elts=None):
-    transform_func = partial(
-        _generic_transform,
-        klass=klass,
-        iterables=iterables,
-        build_elts=build_elts)
-
-    return _generic_inference(node, context, klass, transform_func)
-
-# pylint: disable=invalid-name
-infer_tuple = partial(
-    _infer_builtin,
-    klass=nodes.Tuple,
-    iterables=(nodes.List, nodes.Set),
-    build_elts=tuple)
-
-infer_list = partial(
-    _infer_builtin,
-    klass=nodes.List,
-    iterables=(nodes.Tuple, nodes.Set),
-    build_elts=list)
-
-infer_set = partial(
-    _infer_builtin,
-    klass=nodes.Set,
-    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:
-        inferred = next(arg.infer(context))
-    except (InferenceError, UnresolvableName):
-        raise UseInferenceDefault()
-    if isinstance(inferred, nodes.Dict):
-        items = inferred.items
-    elif is_iterable(inferred):
-        items = []
-        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,
-            # tuples and consts. We are choosing Names as well.
-            if not is_iterable(elt):
-                raise UseInferenceDefault()
-            if len(elt.elts) != 2:
-                raise UseInferenceDefault()
-            if not isinstance(elt.elts[0],
-                              (nodes.Tuple, nodes.Const, nodes.Name)):
-                raise UseInferenceDefault()
-            items.append(tuple(elt.elts))
-    else:
-        raise UseInferenceDefault()
-    return items
-
-def infer_dict(node, context=None):
-    """Try to infer a dict call to a Dict node.
-
-    The function treats the following cases:
-
-        * dict()
-        * dict(mapping)
-        * dict(iterable)
-        * dict(iterable, **kwargs)
-        * dict(mapping, **kwargs)
-        * dict(**kwargs)
-
-    If a case can't be inferred, we'll fallback to default inference.
-    """
-    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 kwargs and not args:
-        # dict(a=1, b=2, c=4)
-        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(args[0], context)
-        keys = [(nodes.Const(key), value) for key, value in kwargs]
-        items = elts + keys
-    elif len(args) == 1:
-        items = _get_elts(args[0], context)
-    else:
-        raise UseInferenceDefault()
-
-    empty = nodes.Dict()
-    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

@@ -1,15 +0,0 @@
-"""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/brain_gi.py

@@ -1,195 +0,0 @@
-"""Astroid hooks for the Python 2 GObject introspection bindings.
-
-Helps with understanding everything imported from 'gi.repository'
-"""
-
-import inspect
-import itertools
-import sys
-import re
-import warnings
-
-from astroid import MANAGER, AstroidBuildingException, nodes
-from astroid.builder import AstroidBuilder
-
-
-_inspected_modules = {}
-
-_identifier_re = r'^[A-Za-z_]\w*$'
-
-def _gi_build_stub(parent):
-    """
-    Inspect the passed module recursively and build stubs for functions,
-    classes, etc.
-    """
-    classes = {}
-    functions = {}
-    constants = {}
-    methods = {}
-    for name in dir(parent):
-        if name.startswith("__"):
-            continue
-
-        # Check if this is a valid name in python
-        if not re.match(_identifier_re, name):
-            continue
-
-        try:
-            obj = getattr(parent, name)
-        except:
-            continue
-
-        if inspect.isclass(obj):
-            classes[name] = obj
-        elif (inspect.isfunction(obj) or
-              inspect.isbuiltin(obj)):
-            functions[name] = obj
-        elif (inspect.ismethod(obj) or
-              inspect.ismethoddescriptor(obj)):
-            methods[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
-        else:
-            # Assume everything else is some manner of constant
-            constants[name] = 0
-
-    ret = ""
-
-    if constants:
-        ret += "# %s contants\n\n" % parent.__name__
-    for name in sorted(constants):
-        if name[0].isdigit():
-            # GDK has some busted constant names like
-            # Gdk.EventType.2BUTTON_PRESS
-            continue
-
-        val = constants[name]
-
-        strval = str(val)
-        if isinstance(val, str):
-            strval = '"%s"' % str(val).replace("\\", "\\\\")
-        ret += "%s = %s\n" % (name, strval)
-
-    if ret:
-        ret += "\n\n"
-    if functions:
-        ret += "# %s functions\n\n" % parent.__name__
-    for name in sorted(functions):
-        ret += "def %s(*args, **kwargs):\n" % name
-        ret += "    pass\n"
-
-    if ret:
-        ret += "\n\n"
-    if methods:
-        ret += "# %s methods\n\n" % parent.__name__
-    for name in sorted(methods):
-        ret += "def %s(self, *args, **kwargs):\n" % name
-        ret += "    pass\n"
-
-    if ret:
-        ret += "\n\n"
-    if classes:
-        ret += "# %s classes\n\n" % parent.__name__
-    for name in sorted(classes):
-        ret += "class %s(object):\n" % name
-
-        classret = _gi_build_stub(classes[name])
-        if not classret:
-            classret = "pass\n"
-
-        for line in classret.splitlines():
-            ret += "    " + line + "\n"
-        ret += "\n"
-
-    return ret
-
-def _import_gi_module(modname):
-    # we only consider gi.repository submodules
-    if not modname.startswith('gi.repository.'):
-        raise AstroidBuildingException()
-    # build astroid representation unless we already tried so
-    if modname not in _inspected_modules:
-        modnames = [modname]
-        optional_modnames = []
-
-        # GLib and GObject may have some special case handling
-        # in pygobject that we need to cope with. However at
-        # least as of pygobject3-3.13.91 the _glib module doesn't
-        # exist anymore, so if treat these modules as optional.
-        if modname == 'gi.repository.GLib':
-            optional_modnames.append('gi._glib')
-        elif modname == 'gi.repository.GObject':
-            optional_modnames.append('gi._gobject')
-
-        try:
-            modcode = ''
-            for m in itertools.chain(modnames, optional_modnames):
-                try:
-                    __import__(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
-        except ImportError:
-            astng = _inspected_modules[modname] = None
-        else:
-            astng = AstroidBuilder(MANAGER).string_build(modcode, modname)
-            _inspected_modules[modname] = astng
-    else:
-        astng = _inspected_modules[modname]
-    if astng is None:
-        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
-
-    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)