libv8 6.7.288.46.1 → 7.3.492.27.0beta1

data/vendor/depot_tools/third_party/pylint/checkers/logging.py

@@ -14,13 +14,15 @@
 """checker for use of Python logging
 """
 
+import six
+
 import astroid
+
 from pylint import checkers
 from pylint import interfaces
 from pylint.checkers import utils
 from pylint.checkers.utils import check_messages
 
-import six
 
 
 MSGS = {
@@ -35,7 +37,7 @@ MSGS = {
               'interpolation in those cases in which no message will be '
               'logged. For more, see '
               'http://www.python.org/dev/peps/pep-0282/.'),
-    'W1202': ('Use % formatting in logging functions but pass the % '
+    'W1202': ('Use % formatting in logging functions and pass the % '
               'parameters as arguments',
               'logging-format-interpolation',
               'Used when a logging statement has a call form of '
@@ -76,7 +78,7 @@ def is_method_call(callfunc_node, types=(), methods=()):
       True, if the node represents a method call for the given type and
       method names, False otherwise.
     """
-    if not isinstance(callfunc_node, astroid.CallFunc):
+    if not isinstance(callfunc_node, astroid.Call):
         return False
     func = utils.safe_infer(callfunc_node.func)
     return (isinstance(func, astroid.BoundMethod)
@@ -117,7 +119,7 @@ class LoggingChecker(checkers.BaseChecker):
             if len(parts) > 1:
                 self._from_imports[parts[0]] = parts[1]
 
-    def visit_from(self, node):
+    def visit_importfrom(self, node):
         """Checks to see if a module uses a non-Python logging module."""
         try:
             logging_name = self._from_imports[node.modname]
@@ -134,10 +136,10 @@ class LoggingChecker(checkers.BaseChecker):
                 self._logging_names.add(as_name or module)
 
     @check_messages(*(MSGS.keys()))
-    def visit_callfunc(self, node):
+    def visit_call(self, node):
         """Checks calls to logging methods."""
         def is_logging_name():
-            return (isinstance(node.func, astroid.Getattr) and
+            return (isinstance(node.func, astroid.Attribute) and
                     isinstance(node.func.expr, astroid.Name) and
                     node.func.expr.name in self._logging_names)
 
@@ -146,7 +148,7 @@ class LoggingChecker(checkers.BaseChecker):
                 for inferred in node.func.infer():
                     if isinstance(inferred, astroid.BoundMethod):
                         parent = inferred._proxied.parent
-                        if (isinstance(parent, astroid.Class) and
+                        if (isinstance(parent, astroid.ClassDef) and
                                 (parent.qname() == 'logging.Logger' or
                                  any(ancestor.qname() == 'logging.Logger'
                                      for ancestor in parent.ancestors()))):
@@ -182,7 +184,7 @@ class LoggingChecker(checkers.BaseChecker):
 
         if isinstance(node.args[format_pos], astroid.BinOp) and node.args[format_pos].op == '%':
             self.add_message('logging-not-lazy', node=node)
-        elif isinstance(node.args[format_pos], astroid.CallFunc):
+        elif isinstance(node.args[format_pos], astroid.Call):
             self._check_call_func(node.args[format_pos])
         elif isinstance(node.args[format_pos], astroid.Const):
             self._check_format_string(node, format_pos)

data/vendor/depot_tools/third_party/pylint/checkers/misc.py

@@ -19,9 +19,10 @@ Check source code is ascii only or has an encoding declaration (PEP 263)
 
 import re
 
+import six
+
 from pylint.interfaces import IRawChecker
 from pylint.checkers import BaseChecker
-import six
 
 
 MSGS = {

data/vendor/depot_tools/third_party/pylint/checkers/newstyle.py

@@ -23,8 +23,8 @@ from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE, HIG
 from pylint.checkers import BaseChecker
 from pylint.checkers.utils import (
     check_messages,
-    has_known_bases,
     node_frame_class,
+    has_known_bases
 )
 
 MSGS = {
@@ -77,7 +77,7 @@ class NewStyleConflictChecker(BaseChecker):
     options = ()
 
     @check_messages('slots-on-old-class', 'old-style-class')
-    def visit_class(self, node):
+    def visit_classdef(self, node):
         """ Check __slots__ in old style classes and old
         style class definition.
         """
@@ -95,10 +95,10 @@ class NewStyleConflictChecker(BaseChecker):
             self.add_message('old-style-class', node=node, confidence=HIGH)
 
     @check_messages('property-on-old-class')
-    def visit_callfunc(self, node):
+    def visit_call(self, node):
         """check property usage"""
         parent = node.parent.frame()
-        if (isinstance(parent, astroid.Class) and
+        if (isinstance(parent, astroid.ClassDef) and
                 not parent.newstyle and
                 isinstance(node.func, astroid.Name)):
             confidence = (INFERENCE if has_known_bases(parent)
@@ -109,62 +109,59 @@ class NewStyleConflictChecker(BaseChecker):
                                  confidence=confidence)
 
     @check_messages('super-on-old-class', 'bad-super-call', 'missing-super-argument')
-    def visit_function(self, node):
+    def visit_functiondef(self, node):
         """check use of super"""
         # ignore actual functions or method within a new style class
         if not node.is_method():
             return
         klass = node.parent.frame()
-        for stmt in node.nodes_of_class(astroid.CallFunc):
+        for stmt in node.nodes_of_class(astroid.Call):
             if node_frame_class(stmt) != node_frame_class(node):
                 # Don't look down in other scopes.
                 continue
             expr = stmt.func
-            if not isinstance(expr, astroid.Getattr):
+            if not isinstance(expr, astroid.Attribute):
                 continue
             call = expr.expr
             # skip the test if using super
-            if isinstance(call, astroid.CallFunc) and \
-               isinstance(call.func, astroid.Name) and \
-               call.func.name == 'super':
-                confidence = (INFERENCE if has_known_bases(klass)
-                              else INFERENCE_FAILURE)
-                if not klass.newstyle:
-                    # super should not be used on an old style class
-                    self.add_message('super-on-old-class', node=node,
-                                     confidence=confidence)
-                else:
-                    # super first arg should be the class
-                    if not call.args and sys.version_info[0] == 3:
-                        # unless Python 3
-                        continue
-
-                    try:
-                        supcls = (call.args and next(call.args[0].infer())
-                                  or None)
-                    except astroid.InferenceError:
-                        continue
-
-                    if supcls is None:
-                        self.add_message('missing-super-argument', node=call,
-                                         confidence=confidence)
-                        continue
-
-                    if klass is not supcls:
-                        name = None
-                        # if supcls is not YES, then supcls was infered
-                        # and use its name. Otherwise, try to look
-                        # for call.args[0].name
-                        if supcls is not astroid.YES:
-                            name = supcls.name
-                        else:
-                            if hasattr(call.args[0], 'name'):
-                                name = call.args[0].name
-                        if name is not None:
-                            self.add_message('bad-super-call',
-                                             node=call,
-                                             args=(name, ),
-                                             confidence=confidence)
+            if not (isinstance(call, astroid.Call) and
+                    isinstance(call.func, astroid.Name) and
+                    call.func.name == 'super'):
+                continue
+
+            if not klass.newstyle and has_known_bases(klass):
+                # super should not be used on an old style class
+                self.add_message('super-on-old-class', node=node)
+            else:
+                # super first arg should be the class
+                if not call.args and sys.version_info[0] == 3:
+                    # unless Python 3
+                    continue
+
+                try:
+                    supcls = (call.args and next(call.args[0].infer())
+                              or None)
+                except astroid.InferenceError:
+                    continue
+
+                if supcls is None:
+                    self.add_message('missing-super-argument', node=call)
+                    continue
+
+                if klass is not supcls:
+                    name = None
+                    # if supcls is not YES, then supcls was infered
+                    # and use its name. Otherwise, try to look
+                    # for call.args[0].name
+                    if supcls is not astroid.YES:
+                        name = supcls.name
+                    else:
+                        if hasattr(call.args[0], 'name'):
+                            name = call.args[0].name
+                    if name is not None:
+                        self.add_message('bad-super-call', node=call, args=(name, ))
+
+    visit_asyncfunctiondef = visit_functiondef
 
 
 def register(linter):

data/vendor/depot_tools/third_party/pylint/checkers/python3.py

@@ -19,6 +19,7 @@ import tokenize
 
 import astroid
 from astroid import bases
+
 from pylint import checkers, interfaces
 from pylint.utils import WarningScope
 from pylint.checkers import utils
@@ -50,7 +51,7 @@ def _check_dict_node(node):
 def _is_builtin(node):
     return getattr(node, 'name', None) in ('__builtin__', 'builtins')
 
-_accepts_iterator = {'iter', 'list', 'tuple', 'sorted', 'set', 'sum', 'any',
+_ACCEPTS_ITERATOR = {'iter', 'list', 'tuple', 'sorted', 'set', 'sum', 'any',
                      'all', 'enumerate', 'dict'}
 
 def _in_iterating_context(node):
@@ -71,12 +72,12 @@ def _in_iterating_context(node):
             return True
     # Various built-ins can take in an iterable or list and lead to the same
     # value.
-    elif isinstance(parent, astroid.CallFunc):
+    elif isinstance(parent, astroid.Call):
         if isinstance(parent.func, astroid.Name):
             parent_scope = parent.func.lookup(parent.func.name)[0]
-            if _is_builtin(parent_scope) and parent.func.name in _accepts_iterator:
+            if _is_builtin(parent_scope) and parent.func.name in _ACCEPTS_ITERATOR:
                 return True
-        elif isinstance(parent.func, astroid.Getattr):
+        elif isinstance(parent.func, astroid.Attribute):
             if parent.func.attrname == 'join':
                 return True
     # If the call is in an unpacking, there's no need to warn,
@@ -130,6 +131,11 @@ class Python3Checker(checkers.BaseChecker):
                   {'scope': WarningScope.NODE,
                    'maxversion': (3, 0),
                    'old_names': [('W0333', 'backtick')]}),
+        'E1609': ('Import * only allowed at module level',
+                  'import-star-module-level',
+                  'Used when the import star syntax is used somewhere '
+                  'else than the module level.',
+                  {'maxversion': (3, 0)}),
         'W1601': ('apply built-in referenced',
                   'apply-builtin',
                   'Used when the apply built-in function is referenced '
@@ -242,7 +248,7 @@ class Python3Checker(checkers.BaseChecker):
                   "Used when an object's next() method is called "
                   '(Python 3 uses the next() built-in function)',
                   {'maxversion': (3, 0)}),
-        'W1623': ("Assigning to a class' __metaclass__ attribute",
+        'W1623': ("Assigning to a class's __metaclass__ attribute",
                   'metaclass-assignment',
                   "Used when a metaclass is specified by assigning to __metaclass__ "
                   '(Python 3 specifies the metaclass as a class statement argument)',
@@ -378,7 +384,7 @@ class Python3Checker(checkers.BaseChecker):
         self._future_division = False
         self._future_absolute_import = False
 
-    def visit_function(self, node):
+    def visit_functiondef(self, node):
         if node.is_method() and node.name in self._unused_magic_methods:
             method_name = node.name
             if node.name.startswith('__'):
@@ -403,8 +409,7 @@ class Python3Checker(checkers.BaseChecker):
     def visit_print(self, node):
         self.add_message('print-statement', node=node)
 
-    @utils.check_messages('no-absolute-import')
-    def visit_from(self, node):
+    def visit_importfrom(self, node):
         if node.modname == '__future__':
             for name, _ in node.names:
                 if name == 'division':
@@ -412,7 +417,12 @@ class Python3Checker(checkers.BaseChecker):
                 elif name == 'absolute_import':
                     self._future_absolute_import = True
         elif not self._future_absolute_import:
-            self.add_message('no-absolute-import', node=node)
+            if self.linter.is_message_enabled('no-absolute-import'):
+                self.add_message('no-absolute-import', node=node)
+        if node.names[0][0] == '*':
+            if self.linter.is_message_enabled('import-star-module-level'):
+                if not isinstance(node.scope(), astroid.Module):
+                    self.add_message('import-star-module-level', node=node)
 
     @utils.check_messages('no-absolute-import')
     def visit_import(self, node):
@@ -420,7 +430,7 @@ class Python3Checker(checkers.BaseChecker):
             self.add_message('no-absolute-import', node=node)
 
     @utils.check_messages('metaclass-assignment')
-    def visit_class(self, node):
+    def visit_classdef(self, node):
         if '__metaclass__' in node.locals:
             self.add_message('metaclass-assignment', node=node)
 
@@ -435,8 +445,8 @@ class Python3Checker(checkers.BaseChecker):
 
     def _check_cmp_argument(self, node):
         # Check that the `cmp` argument is used
-        args = []
-        if (isinstance(node.func, astroid.Getattr)
+        kwargs = []
+        if (isinstance(node.func, astroid.Attribute)
                 and node.func.attrname == 'sort'):
             inferred = utils.safe_infer(node.func.expr)
             if not inferred:
@@ -445,28 +455,28 @@ class Python3Checker(checkers.BaseChecker):
             builtins_list = "{}.list".format(bases.BUILTINS)
             if (isinstance(inferred, astroid.List)
                     or inferred.qname() == builtins_list):
-                args = node.args
+                kwargs = node.keywords
 
         elif (isinstance(node.func, astroid.Name)
-                and node.func.name == 'sorted'):
+              and node.func.name == 'sorted'):
             inferred = utils.safe_infer(node.func)
             if not inferred:
                 return
 
             builtins_sorted = "{}.sorted".format(bases.BUILTINS)
             if inferred.qname() == builtins_sorted:
-                args = node.args
+                kwargs = node.keywords
 
-        for arg in args:
-            if isinstance(arg, astroid.Keyword) and arg.arg == 'cmp':
+        for kwarg in kwargs or []:
+            if kwarg.arg == 'cmp':
                 self.add_message('using-cmp-argument', node=node)
                 return
 
-    def visit_callfunc(self, node):
+    def visit_call(self, node):
         self._check_cmp_argument(node)
 
-        if isinstance(node.func, astroid.Getattr):
-            if any([node.args, node.starargs, node.kwargs]):
+        if isinstance(node.func, astroid.Attribute):
+            if any([node.args, node.keywords]):
                 return
             if node.func.attrname == 'next':
                 self.add_message('next-method-called', node=node)
@@ -504,7 +514,7 @@ class Python3Checker(checkers.BaseChecker):
             self.add_message('unpacking-in-except', node=node)
 
     @utils.check_messages('backtick')
-    def visit_backquote(self, node):
+    def visit_repr(self, node):
         self.add_message('backtick', node=node)
 
     @utils.check_messages('raising-string', 'old-raise-syntax')

data/vendor/depot_tools/third_party/pylint/checkers/raw_metrics.py

@@ -25,12 +25,12 @@ import tokenize
 #if not hasattr(tokenize, 'NL'):
 #    raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
 
-from logilab.common.ureports import Table
-
 from pylint.interfaces import ITokenChecker
 from pylint.utils import EmptyReport
 from pylint.checkers import BaseTokenChecker
 from pylint.reporters import diff_string
+from pylint.reporters.ureports.nodes import Table
+
 
 def report_raw_stats(sect, stats, old_stats):
     """calculate percentage of code / doc / comment / empty
@@ -118,7 +118,7 @@ def get_type(tokens, start_index):
         i += 1
     if line_type is None:
         line_type = 'empty_lines'
-    elif i < len(tokens) and tok_type == tokenize.NEWLINE:
+    elif i < len(tokens) and tokens[i][0] == tokenize.NEWLINE:
         i += 1
     return i, pos[0] - start[0] + 1, line_type
 

data/vendor/depot_tools/third_party/pylint/checkers/similar.py

@@ -20,13 +20,12 @@ from __future__ import print_function
 import sys
 from collections import defaultdict
 
-from logilab.common.ureports import Table
+import six
+from six.moves import zip
 
 from pylint.interfaces import IRawChecker
 from pylint.checkers import BaseChecker, table_lines_from_stats
-
-import six
-from six.moves import zip
+from pylint.reporters.ureports.nodes import Table
 
 
 class Similar(object):
@@ -306,7 +305,7 @@ class SimilarChecker(BaseChecker, Similar):
 
     def close(self):
         """compute and display similarities on closing (i.e. end of parsing)"""
-        total = sum([len(lineset) for lineset in self.linesets])
+        total = sum(len(lineset) for lineset in self.linesets)
         duplicated = 0
         stats = self.stats
         for num, couples in self._compute_sims():

data/vendor/depot_tools/third_party/pylint/checkers/spelling.py

@@ -15,24 +15,26 @@
 """Checker for spelling errors in comments and docstrings.
 """
 
+import os
 import sys
 import tokenize
 import string
 import re
 
-if sys.version_info[0] >= 3:
-    maketrans = str.maketrans
-else:
-    maketrans = string.maketrans
+try:
+    import enchant
+except ImportError:
+    enchant = None
+import six
 
 from pylint.interfaces import ITokenChecker, IAstroidChecker
 from pylint.checkers import BaseTokenChecker
 from pylint.checkers.utils import check_messages
 
-try:
-    import enchant
-except ImportError:
-    enchant = None
+if sys.version_info[0] >= 3:
+    maketrans = str.maketrans
+else:
+    maketrans = string.maketrans
 
 if enchant is not None:
     br = enchant.Broker()
@@ -48,6 +50,7 @@ else:
 
 table = maketrans("", "")
 
+
 class SpellingChecker(BaseTokenChecker):
     """Check spelling in comments and docstrings"""
     __implements__ = (ITokenChecker, IAstroidChecker)
@@ -105,6 +108,11 @@ class SpellingChecker(BaseTokenChecker):
         # "pylint" appears in comments in pylint pragmas.
         self.ignore_list.extend(["param", "pylint"])
 
+        # Expand tilde to allow e.g. spelling-private-dict-file = ~/.pylintdict
+        if self.config.spelling_private_dict_file:
+            self.config.spelling_private_dict_file = os.path.expanduser(
+                self.config.spelling_private_dict_file)
+
         if self.config.spelling_private_dict_file:
             self.spelling_dict = enchant.DictWithPWL(
                 dict_name, self.config.spelling_private_dict_file)
@@ -220,17 +228,19 @@ class SpellingChecker(BaseTokenChecker):
         self._check_docstring(node)
 
     @check_messages('wrong-spelling-in-docstring')
-    def visit_class(self, node):
+    def visit_classdef(self, node):
         if not self.initialized:
             return
         self._check_docstring(node)
 
     @check_messages('wrong-spelling-in-docstring')
-    def visit_function(self, node):
+    def visit_functiondef(self, node):
         if not self.initialized:
             return
         self._check_docstring(node)
 
+    visit_asyncfunctiondef = visit_functiondef
+
     def _check_docstring(self, node):
         """check the node has any spelling errors"""
         docstring = node.doc
@@ -238,6 +248,10 @@ class SpellingChecker(BaseTokenChecker):
             return
 
         start_line = node.lineno + 1
+        if six.PY2:
+            encoding = node.root().file_encoding
+            docstring = docstring.decode(encoding or sys.getdefaultencoding(),
+                                         'replace')
 
         # Go through lines of docstring
         for idx, line in enumerate(docstring.splitlines()):