libv8 6.3.292.48.1 → 6.7.288.46.0

data/vendor/depot_tools/recipes/recipes.py

@@ -107,7 +107,9 @@ def parse(repo_root, recipes_cfg_path):
     raise MalformedRecipesCfg(ex.message, recipes_cfg_path)
 
 
-GIT = 'git.bat' if sys.platform.startswith(('win', 'cygwin')) else 'git'
+_BAT = '.bat' if sys.platform.startswith(('win', 'cygwin')) else ''
+GIT = 'git' + _BAT
+VPYTHON = 'vpython' + _BAT
 
 
 def _subprocess_call(argv, **kwargs):
@@ -208,7 +210,7 @@ def main():
   engine_path = checkout_engine(engine_override, repo_root, recipes_cfg_path)
 
   return _subprocess_call([
-      sys.executable, '-u',
+      VPYTHON, '-u',
       os.path.join(engine_path, 'recipes.py')] + args)
 
 

data/vendor/depot_tools/recipes/trigger_recipe_roller.txt

@@ -1 +1,13 @@
 No-op file. Edit this to kick recipes.
+
+This is a beginning of a story in this silly file.
+Once upon a time, a budding web browser dev team needed a CI system.
+All they had was one poor machine under a desk, and its name was Batty,
+the Build and Test Yeti.
+
+As the CI needs of the browser grew, Batty, the Build and Test Yeti, got
+a new friend, but this information was marked RVG, so it was months before
+any details were revealed.
+
+
+The End!

data/vendor/depot_tools/roll_dep.py

@@ -10,6 +10,8 @@ script will always roll to the tip of to origin/master.
 """
 
 import argparse
+import collections
+import gclient_eval
 import os
 import re
 import subprocess
@@ -68,6 +70,12 @@ def should_show_log(upstream_url):
   return True
 
 
+def get_gclient_root():
+  gclient = os.path.join(
+      os.path.dirname(os.path.abspath(__file__)), 'gclient.py')
+  return check_output([sys.executable, gclient, 'root']).strip()
+
+
 def get_deps(root):
   """Returns the path and the content of the DEPS file."""
   deps_path = os.path.join(root, 'DEPS')
@@ -122,27 +130,13 @@ def generate_commit_message(
   return header + log_section
 
 
-def calculate_roll(full_dir, dependency, deps_content, roll_to, key):
-  """Calculates the roll for a dependency by processing deps_content, and
+def calculate_roll(full_dir, dependency, gclient_dict, roll_to):
+  """Calculates the roll for a dependency by processing gclient_dict, and
   fetching the dependency via git.
   """
-  head = check_output(['git', 'rev-parse', 'HEAD'], cwd=full_dir).strip()
-  if not head in deps_content:
-    print('Warning: %s is not checked out at the expected revision in DEPS' %
-          dependency)
-    if not key:
-      key = dependency
-
-    # It happens if the user checked out a branch in the dependency by himself.
-    # Fall back to reading the DEPS to figure out the original commit.
-    for i in deps_content.splitlines():
-      m = re.match(r'\s+"' + key + '":.*"([a-z0-9]{40})",', i)
-      if m:
-        head = m.group(1)
-        break
-    else:
-      raise Error('Expected to find commit %s for %s in DEPS' % (head, key))
-
+  head = gclient_eval.GetRevision(gclient_dict, dependency)
+  if not head:
+    raise Error('%s is unpinned.' % dependency)
   check_call(['git', 'fetch', 'origin', '--quiet'], cwd=full_dir)
   roll_to = check_output(['git', 'rev-parse', roll_to], cwd=full_dir).strip()
   return head, roll_to
@@ -154,28 +148,27 @@ def gen_commit_msg(logs, cmdline, rolls, reviewers, bug):
   if len(logs) > 1:
     commit_msg = 'Rolling %d dependencies\n\n' % len(logs)
   commit_msg += '\n\n'.join(logs)
-  commit_msg += '\nCreated with:\n  ' + cmdline
+  commit_msg += '\nCreated with:\n  ' + cmdline + '\n'
   commit_msg += 'R=%s\n' % ','.join(reviewers) if reviewers else ''
   commit_msg += 'BUG=%s\n' % bug if bug else ''
   return commit_msg
 
 
-def finalize(commit_msg, deps_path, deps_content, rolls):
+def finalize(commit_msg, deps_path, deps_content, rolls, is_relative, root_dir):
   """Edits the DEPS file, commits it, then uploads a CL."""
   print('Commit message:')
   print('\n'.join('    ' + i for i in commit_msg.splitlines()))
 
   with open(deps_path, 'wb') as f:
     f.write(deps_content)
-  root = os.path.dirname(deps_path)
-  check_call(['git', 'add', 'DEPS'], cwd=root)
-  check_call(['git', 'commit', '--quiet', '-m', commit_msg], cwd=root)
+  current_dir = os.path.dirname(deps_path)
+  check_call(['git', 'add', 'DEPS'], cwd=current_dir)
+  check_call(['git', 'commit', '--quiet', '-m', commit_msg], cwd=current_dir)
 
   # Pull the dependency to the right revision. This is surprising to users
   # otherwise.
   for dependency, (_head, roll_to) in sorted(rolls.iteritems()):
-    full_dir = os.path.normpath(
-        os.path.join(os.path.dirname(root), dependency))
+    full_dir = os.path.normpath(os.path.join(root_dir, dependency))
     check_call(['git', 'checkout', '--quiet', roll_to], cwd=full_dir)
 
 
@@ -220,24 +213,28 @@ def main():
       if not '@' in r:
         reviewers[i] = r + '@chromium.org'
 
-  root = os.getcwd()
+  gclient_root = get_gclient_root()
+  current_dir = os.getcwd()
   dependencies = sorted(d.rstrip('/').rstrip('\\') for d in args.dep_path)
   cmdline = 'roll-dep ' + ' '.join(dependencies) + ''.join(
       ' --key ' + k for k in args.key)
   try:
-    if not args.ignore_dirty_tree and not is_pristine(root):
-      raise Error('Ensure %s is clean first (no non-merged commits).' % root)
+    if not args.ignore_dirty_tree and not is_pristine(current_dir):
+      raise Error(
+          'Ensure %s is clean first (no non-merged commits).' % current_dir)
     # First gather all the information without modifying anything, except for a
     # git fetch.
-    deps_path, deps_content = get_deps(root)
+    deps_path, deps_content = get_deps(current_dir)
+    gclient_dict = gclient_eval.Exec(deps_content, deps_path)
+    is_relative = gclient_dict.get('use_relative_paths', False)
+    root_dir = current_dir if is_relative else gclient_root
     rolls = {}
     for dependency in dependencies:
-      full_dir = os.path.normpath(
-          os.path.join(os.path.dirname(root), dependency))
+      full_dir = os.path.normpath(os.path.join(root_dir, dependency))
       if not os.path.isdir(full_dir):
         raise Error('Directory not found: %s (%s)' % (dependency, full_dir))
       head, roll_to = calculate_roll(
-          full_dir, dependency, deps_content, args.roll_to, args.key)
+          full_dir, dependency, gclient_dict, args.roll_to)
       if roll_to == head:
         if len(dependencies) == 1:
           raise AlreadyRolledError('No revision to roll!')
@@ -249,15 +246,16 @@ def main():
 
     logs = []
     for dependency, (head, roll_to) in sorted(rolls.iteritems()):
-      full_dir = os.path.normpath(
-          os.path.join(os.path.dirname(root), dependency))
+      full_dir = os.path.normpath(os.path.join(root_dir, dependency))
       log = generate_commit_message(
           full_dir, dependency, head, roll_to, args.no_log, args.log_limit)
       logs.append(log)
-      deps_content = deps_content.replace(head, roll_to)
+      gclient_eval.SetRevision(gclient_dict, dependency, roll_to)
+
+    deps_content = gclient_eval.RenderDEPSFile(gclient_dict)
 
     commit_msg = gen_commit_msg(logs, cmdline, rolls, reviewers, args.bug)
-    finalize(commit_msg, deps_path, deps_content, rolls)
+    finalize(commit_msg, deps_path, deps_content, rolls, is_relative, root_dir)
   except Error as e:
     sys.stderr.write('error: %s\n' % e)
     return 2 if isinstance(e, AlreadyRolledError) else 1

data/vendor/depot_tools/support/chromite_wrapper

@@ -69,7 +69,7 @@ def main():
   path = os.path.join(chromite_dir, 'bin', target)
   try:
     os.execv(path, [path] + sys.argv[1:])
-  except EnvironmentError, e:
+  except EnvironmentError as e:
     if e.errno not in (errno.ENOENT, errno.EPERM):
       raise
 

data/vendor/depot_tools/third_party/logilab/astroid/README.chromium

@@ -1,10 +1,10 @@
-URL: http://www.logilab.org/project/logilab-astng
-Version: 1.3.4
+URL: https://github.com/PyCQA/astroid
+Version: 1.3.8
 License: GPL
 License File: LICENSE.txt
 
 Description:
-This directory contains the logilab-astng module, required for pylint.
+This directory contains the astroid module, required for pylint.
 
 Local Modifications:
 None

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

@@ -20,10 +20,10 @@ distname = 'astroid'
 
 modname = 'astroid'
 
-numversion = (1, 3, 4)
+numversion = (1, 3, 8)
 version = '.'.join([str(num) for num in numversion])
 
-install_requires = ['logilab-common >= 0.60.0', 'six']
+install_requires = ['logilab-common>=0.63.0', 'six']
 
 license = 'LGPL'
 

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

@@ -0,0 +1,86 @@
+# 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/>.
+"""Small AST optimizations."""
+
+import _ast
+
+from astroid import nodes
+
+
+__all__ = ('ASTPeepholeOptimizer', )
+
+
+try:
+    _TYPES = (_ast.Str, _ast.Bytes)
+except AttributeError:
+    _TYPES = (_ast.Str, )
+
+
+class ASTPeepholeOptimizer(object):
+    """Class for applying small optimizations to generate new AST."""
+
+    def optimize_binop(self, node):
+        """Optimize BinOps with string Const nodes on the lhs.
+
+        This fixes an infinite recursion crash, where multiple
+        strings are joined using the addition operator. With a
+        sufficient number of such strings, astroid will fail
+        with a maximum recursion limit exceeded. The
+        function will return a Const node with all the strings
+        already joined.
+        Return ``None`` if no AST node can be obtained
+        through optimization.
+        """
+        ast_nodes = []
+        current = node
+        while isinstance(current, _ast.BinOp):
+            # lhs must be a BinOp with the addition operand.
+            if not isinstance(current.left, _ast.BinOp):
+                return
+            if (not isinstance(current.left.op, _ast.Add)
+                    or not isinstance(current.op, _ast.Add)):
+                return
+
+            # rhs must a str / bytes.
+            if not isinstance(current.right, _TYPES):
+                return
+
+            ast_nodes.append(current.right.s)
+            current = current.left
+
+            if (isinstance(current, _ast.BinOp)
+                    and isinstance(current.left, _TYPES)
+                    and isinstance(current.right, _TYPES)):
+                # Stop early if we are at the last BinOp in
+                # the operation
+                ast_nodes.append(current.right.s)
+                ast_nodes.append(current.left.s)
+                break
+
+        if not ast_nodes:
+            return
+
+        # If we have inconsistent types, bail out.
+        known = type(ast_nodes[0])
+        if any(type(element) is not known
+               for element in ast_nodes[1:]):
+            return
+
+        value = known().join(reversed(ast_nodes))
+        newnode = nodes.Const(value)
+        return newnode

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

@@ -58,52 +58,28 @@ class Proxy(object):
 
 # Inference ##################################################################
 
-MISSING = object()
-
-
 class InferenceContext(object):
-    __slots__ = ('path', 'callcontext', 'boundnode', 'infered')
-
-    def __init__(self,
-            path=None, callcontext=None, boundnode=None, infered=None):
-        if path is None:
-            self.path = frozenset()
-        else:
-            self.path = path
-        self.callcontext = callcontext
-        self.boundnode = boundnode
-        if infered is None:
-            self.infered = {}
-        else:
-            self.infered = infered
-
-    def push(self, key):
-        # This returns a NEW context with the same attributes, but a new key
-        # added to `path`.  The intention is that it's only passed to callees
-        # and then destroyed; otherwise scope() may not work correctly.
-        # The cache will be shared, since it's the same exact dict.
-        if key in self.path:
-            # End the containing generator
-            raise StopIteration
-
-        return InferenceContext(
-            self.path.union([key]),
-            self.callcontext,
-            self.boundnode,
-            self.infered,
-        )
-
-    @contextmanager
-    def scope(self, callcontext=MISSING, boundnode=MISSING):
-        try:
-            orig = self.callcontext, self.boundnode
-            if callcontext is not MISSING:
-                self.callcontext = callcontext
-            if boundnode is not MISSING:
-                self.boundnode = boundnode
-            yield
-        finally:
-            self.callcontext, self.boundnode = orig
+    __slots__ = ('path', 'lookupname', 'callcontext', 'boundnode', 'infered')
+
+    def __init__(self, path=None, infered=None):
+        self.path = path or set()
+        self.lookupname = None
+        self.callcontext = None
+        self.boundnode = None
+        self.infered = infered or {}
+
+    def push(self, node):
+        name = self.lookupname
+        if (node, name) in self.path:
+            raise StopIteration()
+        self.path.add((node, name))
+
+    def clone(self):
+        # XXX copy lookupname/callcontext ?
+        clone = InferenceContext(self.path, infered=self.infered)
+        clone.callcontext = self.callcontext
+        clone.boundnode = self.boundnode
+        return clone
 
     def cache_generator(self, key, generator):
         results = []
@@ -114,28 +90,38 @@ class InferenceContext(object):
         self.infered[key] = tuple(results)
         return
 
+    @contextmanager
+    def restore_path(self):
+        path = set(self.path)
+        yield
+        self.path = path
 
-def _infer_stmts(stmts, context, frame=None, lookupname=None):
+def copy_context(context):
+    if context is not None:
+        return context.clone()
+    else:
+        return InferenceContext()
+
+
+def _infer_stmts(stmts, context, frame=None):
     """return an iterator on statements inferred by each statement in <stmts>
     """
     stmt = None
     infered = False
-    if context is None:
+    if context is not None:
+        name = context.lookupname
+        context = context.clone()
+    else:
+        name = None
         context = InferenceContext()
     for stmt in stmts:
         if stmt is YES:
             yield stmt
             infered = True
             continue
-
-        kw = {}
-        infered_name = stmt._infer_name(frame, lookupname)
-        if infered_name is not None:
-            # only returns not None if .infer() accepts a lookupname kwarg
-            kw['lookupname'] = infered_name
-
+        context.lookupname = stmt._infer_name(frame, name)
         try:
-            for infered in stmt.infer(context, **kw):
+            for infered in stmt.infer(context):
                 yield infered
                 infered = True
         except UnresolvableName:
@@ -197,12 +183,13 @@ class Instance(Proxy):
             context = InferenceContext()
         try:
             # avoid recursively inferring the same attr on the same class
-            new_context = context.push((self._proxied, name))
+
+            context.push((self._proxied, name))
             # XXX frame should be self._proxied, or not ?
-            get_attr = self.getattr(name, new_context, lookupclass=False)
+            get_attr = self.getattr(name, context, lookupclass=False)
             return _infer_stmts(
-                self._wrap_attr(get_attr, new_context),
-                new_context,
+                self._wrap_attr(get_attr, context),
+                context,
                 frame=self,
             )
         except NotFoundError:
@@ -210,7 +197,7 @@ class Instance(Proxy):
                 # fallback to class'igetattr since it has some logic to handle
                 # descriptors
                 return self._wrap_attr(self._proxied.igetattr(name, context),
-                                            context)
+                                       context)
             except NotFoundError:
                 raise InferenceError(name)
 
@@ -301,9 +288,9 @@ class BoundMethod(UnboundMethod):
         return True
 
     def infer_call_result(self, caller, context):
-        with context.scope(boundnode=self.bound):
-            for infered in self._proxied.infer_call_result(caller, context):
-                yield infered
+        context = context.clone()
+        context.boundnode = self.bound
+        return self._proxied.infer_call_result(caller, context)
 
 
 class Generator(Instance):
@@ -335,8 +322,7 @@ def path_wrapper(func):
         """wrapper function handling context"""
         if context is None:
             context = InferenceContext()
-        context = context.push((node, kwargs.get('lookupname')))
-
+        context.push(node)
         yielded = set()
         for res in _func(node, context, **kwargs):
             # unproxy only true instance, not const, tuple, dict...
@@ -409,7 +395,8 @@ class NodeNG(object):
         if not context:
             return self._infer(context, **kwargs)
 
-        key = (self, kwargs.get('lookupname'), context.callcontext, context.boundnode)
+        key = (self, context.lookupname,
+               context.callcontext, context.boundnode)
         if key in context.infered:
             return iter(context.infered[key])