libv8 6.7.288.46.1 → 7.3.492.27.0beta1

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

@@ -18,7 +18,7 @@
 import re
 from collections import defaultdict
 
-from astroid import If, InferenceError
+from astroid import If, BoolOp
 
 from pylint.interfaces import IAstroidChecker
 from pylint.checkers import BaseChecker
@@ -64,12 +64,27 @@ MSGS = {
               'too-many-statements',
               'Used when a function or method has too many statements. You \
               should then split it in smaller functions / methods.'),
-    'R0923': ('Interface not implemented',
-              'interface-not-implemented',
-              'Used when an interface class is not implemented anywhere.'),
+    'R0916': ('Too many boolean expressions in if statement (%s/%s)',
+              'too-many-boolean-expressions',
+              'Used when a if statement contains too many boolean '
+              'expressions'),
     }
 
 
+def _count_boolean_expressions(bool_op):
+    """Counts the number of boolean expressions in BoolOp `bool_op` (recursive)
+
+    example: a and (b or c or (d and e)) ==> 5 boolean expressions
+    """
+    nb_bool_expr = 0
+    for bool_expr in bool_op.get_children():
+        if isinstance(bool_expr, BoolOp):
+            nb_bool_expr += _count_boolean_expressions(bool_expr)
+        else:
+            nb_bool_expr += 1
+    return nb_bool_expr
+
+
 class MisdesignChecker(BaseChecker):
     """checks for sign of poor/misdesign:
     * number of methods, attributes, local variables...
@@ -139,6 +154,13 @@ class MisdesignChecker(BaseChecker):
                  'help' : 'Maximum number of public methods for a class \
 (see R0904).'}
                ),
+               ('max-bool-expr',
+                {'default': 5,
+                 'type': 'int',
+                 'metavar': '<num>',
+                 'help': 'Maximum number of boolean expressions in a if '
+                         'statement'}
+               ),
               )
 
     def __init__(self, linter=None):
@@ -146,8 +168,6 @@ class MisdesignChecker(BaseChecker):
         self.stats = None
         self._returns = None
         self._branches = None
-        self._used_ifaces = None
-        self._ifaces = None
         self._stmts = 0
 
     def open(self):
@@ -155,19 +175,10 @@ class MisdesignChecker(BaseChecker):
         self.stats = self.linter.add_stats()
         self._returns = []
         self._branches = defaultdict(int)
-        self._used_ifaces = {}
-        self._ifaces = []
-
-    def close(self):
-        """check that interface classes are used"""
-        for iface in self._ifaces:
-            if not iface in self._used_ifaces:
-                self.add_message('interface-not-implemented', node=iface)
 
     @check_messages('too-many-ancestors', 'too-many-instance-attributes',
-                    'too-few-public-methods', 'too-many-public-methods',
-                    'interface-not-implemented')
-    def visit_class(self, node):
+                    'too-few-public-methods', 'too-many-public-methods')
+    def visit_classdef(self, node):
         """check size of inheritance hierarchy and number of instance attributes
         """
         # Is the total inheritance hierarchy is 7 or less?
@@ -182,22 +193,9 @@ class MisdesignChecker(BaseChecker):
             self.add_message('too-many-instance-attributes', node=node,
                              args=(len(node.instance_attrs),
                                    self.config.max_attributes))
-        # update interface classes structures
-        if node.type == 'interface' and node.name != 'Interface':
-            self._ifaces.append(node)
-            for parent in node.ancestors(False):
-                if parent.name == 'Interface':
-                    continue
-                self._used_ifaces[parent] = 1
-        try:
-            for iface in node.interfaces():
-                self._used_ifaces[iface] = 1
-        except InferenceError:
-            # XXX log ?
-            pass
 
     @check_messages('too-few-public-methods', 'too-many-public-methods')
-    def leave_class(self, node):
+    def leave_classdef(self, node):
         """check number of public methods"""
         my_methods = sum(1 for method in node.mymethods()
                          if not method.name.startswith('_'))
@@ -230,7 +228,7 @@ class MisdesignChecker(BaseChecker):
     @check_messages('too-many-return-statements', 'too-many-branches',
                     'too-many-arguments', 'too-many-locals',
                     'too-many-statements')
-    def visit_function(self, node):
+    def visit_functiondef(self, node):
         """check function name, docstring, arguments, redefinition,
         variable names, max locals
         """
@@ -256,10 +254,12 @@ class MisdesignChecker(BaseChecker):
         # init statements counter
         self._stmts = 1
 
+    visit_asyncfunctiondef = visit_functiondef
+
     @check_messages('too-many-return-statements', 'too-many-branches',
                     'too-many-arguments', 'too-many-locals',
                     'too-many-statements')
-    def leave_function(self, node):
+    def leave_functiondef(self, node):
         """most of the work is done here on close:
         checks for max returns, branch, return in __init__
         """
@@ -276,6 +276,8 @@ class MisdesignChecker(BaseChecker):
             self.add_message('too-many-statements', node=node,
                              args=(self._stmts, self.config.max_statements))
 
+    leave_asyncfunctiondef = leave_functiondef
+
     def visit_return(self, _):
         """count number of returns"""
         if not self._returns:
@@ -302,8 +304,10 @@ class MisdesignChecker(BaseChecker):
         self._inc_branch(node, 2)
         self._stmts += 2
 
+    @check_messages('too-many-boolean-expressions')
     def visit_if(self, node):
-        """increments the branches counter"""
+        """increments the branches counter and checks boolean expressions"""
+        self._check_boolean_expressions(node)
         branches = 1
         # don't double count If nodes coming from some 'elif'
         if node.orelse and (len(node.orelse) > 1 or
@@ -312,6 +316,19 @@ class MisdesignChecker(BaseChecker):
         self._inc_branch(node, branches)
         self._stmts += branches
 
+    def _check_boolean_expressions(self, node):
+        """Go through "if" node `node` and counts its boolean expressions
+
+        if the "if" node test is a BoolOp node
+        """
+        condition = node.test
+        if not isinstance(condition, BoolOp):
+            return
+        nb_bool_expr = _count_boolean_expressions(condition)
+        if nb_bool_expr > self.config.max_bool_expr:
+            self.add_message('too-many-boolean-expressions', node=condition,
+                             args=(nb_bool_expr, self.config.max_bool_expr))
+
     def visit_while(self, node):
         """increments the branches counter"""
         branches = 1

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

@@ -14,22 +14,30 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 """exceptions handling (raising, catching, exceptions classes) checker
 """
+import inspect
 import sys
 
-import astroid
-from astroid import YES, Instance, unpack_infer, List, Tuple
-from logilab.common.compat import builtins
+import six
+from six.moves import builtins
 
+import astroid
 from pylint.checkers import BaseChecker
 from pylint.checkers.utils import (
-    is_empty,
     is_raising,
     check_messages,
     inherit_from_std_ex,
     EXCEPTIONS_MODULE,
-    has_known_bases,
-    safe_infer)
-from pylint.interfaces import IAstroidChecker, INFERENCE, INFERENCE_FAILURE
+    safe_infer,
+    has_known_bases)
+from pylint.interfaces import IAstroidChecker
+
+
+def _builtin_exceptions():
+    def predicate(obj):
+        return isinstance(obj, type) and issubclass(obj, BaseException)
+
+    members = inspect.getmembers(six.moves.builtins, predicate)
+    return {exc.__name__ for (_, exc) in members}
 
 
 def _annotated_unpack_infer(stmt, context=None):
@@ -39,14 +47,14 @@ def _annotated_unpack_infer(stmt, context=None):
     Returns an iterator which yields tuples in the format
     ('original node', 'infered node').
     """
-    if isinstance(stmt, (List, Tuple)):
+    if isinstance(stmt, (astroid.List, astroid.Tuple)):
         for elt in stmt.elts:
             inferred = safe_infer(elt)
-            if inferred and inferred is not YES:
+            if inferred and inferred is not astroid.YES:
                 yield elt, inferred
         return
     for infered in stmt.infer(context):
-        if infered is YES:
+        if infered is astroid.YES:
             continue
         yield stmt, infered
 
@@ -54,6 +62,7 @@ def _annotated_unpack_infer(stmt, context=None):
 PY3K = sys.version_info >= (3, 0)
 OVERGENERAL_EXCEPTIONS = ('Exception',)
 BUILTINS_NAME = builtins.__name__
+
 MSGS = {
     'E0701': ('Bad except clauses order (%s)',
               'bad-except-order',
@@ -71,6 +80,14 @@ MSGS = {
               'where the exception context is not an exception, '
               'nor None.',
               {'minversion': (3, 0)}),
+    'E0704': ('The raise statement is not inside an except clause',
+              'misplaced-bare-raise',
+              'Used when a bare raise is not used inside an except clause. '
+              'This generates an error, since there are no active exceptions '
+              'to be reraised. An exception to this rule is represented by '
+              'a bare raise inside a finally clause, which might work, as long '
+              'as an exception is raised inside the try block, but it is '
+              'nevertheless a code smell that must not be relied upon.'),
     'E0710': ('Raising a new style class which doesn\'t inherit from BaseException',
               'raising-non-exception',
               'Used when a new style class which doesn\'t inherit from \
@@ -91,10 +108,10 @@ MSGS = {
               'broad-except',
               'Used when an except catches a too general exception, \
               possibly burying unrelated errors.'),
-    'W0704': ('Except doesn\'t do anything',
-              'pointless-except',
-              'Used when an except clause does nothing but "pass" and there is\
-              no "else" clause.'),
+    'W0705': ('Catching previously caught exception type %s',
+              'duplicate-except',
+              'Used when an except catches a type that was already caught by '
+              'a previous handler.'),
     'W0710': ('Exception doesn\'t inherit from standard "Exception" class',
               'nonstandard-exception',
               'Used when a custom exception class is raised but doesn\'t \
@@ -128,13 +145,17 @@ class ExceptionsChecker(BaseChecker):
                ),
               )
 
-    @check_messages('nonstandard-exception',
+    def open(self):
+        self.builtin_exceptions = _builtin_exceptions()
+        super(ExceptionsChecker, self).open()
+
+    @check_messages('nonstandard-exception', 'misplaced-bare-raise',
                     'raising-bad-type', 'raising-non-exception',
                     'notimplemented-raised', 'bad-exception-context')
     def visit_raise(self, node):
         """visit raise possibly inferring value"""
-        # ignore empty raise
         if node.exc is None:
+            self._check_misplaced_bare_raise(node)
             return
         if PY3K and node.cause:
             self._check_bad_exception_context(node)
@@ -144,24 +165,44 @@ class ExceptionsChecker(BaseChecker):
             return
         else:
             try:
-                value = next(unpack_infer(expr))
+                value = next(astroid.unpack_infer(expr))
             except astroid.InferenceError:
                 return
             self._check_raise_value(node, value)
 
+    def _check_misplaced_bare_raise(self, node):
+        # Filter out if it's present in __exit__.
+        scope = node.scope()
+        if (isinstance(scope, astroid.FunctionDef)
+                and scope.is_method()
+                and scope.name == '__exit__'):
+            return
+
+        current = node
+        # Stop when a new scope is generated or when the raise
+        # statement is found inside a TryFinally.
+        ignores = (astroid.ExceptHandler, astroid.FunctionDef, astroid.TryFinally)
+        while current and not isinstance(current.parent, ignores):
+            current = current.parent
+
+        expected = (astroid.ExceptHandler,)
+        if (not current
+                or not isinstance(current.parent, expected)):
+            self.add_message('misplaced-bare-raise', node=node)
+
     def _check_bad_exception_context(self, node):
         """Verify that the exception context is properly set.
 
         An exception context can be only `None` or an exception.
         """
         cause = safe_infer(node.cause)
-        if cause in (YES, None):
+        if cause in (astroid.YES, None):
             return
         if isinstance(cause, astroid.Const):
             if cause.value is not None:
                 self.add_message('bad-exception-context',
                                  node=node)
-        elif (not isinstance(cause, astroid.Class) and
+        elif (not isinstance(cause, astroid.ClassDef) and
               not inherit_from_std_ex(cause)):
             self.add_message('bad-exception-context',
                              node=node)
@@ -179,9 +220,9 @@ class ExceptionsChecker(BaseChecker):
         elif ((isinstance(expr, astroid.Name) and
                expr.name in ('None', 'True', 'False')) or
               isinstance(expr, (astroid.List, astroid.Dict, astroid.Tuple,
-                                astroid.Module, astroid.Function))):
+                                astroid.Module, astroid.FunctionDef))):
             emit = True
-            if not PY3K and isinstance(expr, astroid.Tuple):
+            if not PY3K and isinstance(expr, astroid.Tuple) and expr.elts:
                 # On Python 2, using the following is not an error:
                 #    raise (ZeroDivisionError, None)
                 #    raise (ZeroDivisionError, )
@@ -191,11 +232,11 @@ class ExceptionsChecker(BaseChecker):
                 # the scope of this check.
                 first = expr.elts[0]
                 inferred = safe_infer(first)
-                if isinstance(inferred, Instance):
+                if isinstance(inferred, astroid.Instance):
                     # pylint: disable=protected-access
                     inferred = inferred._proxied
-                if (inferred is YES or
-                        isinstance(inferred, astroid.Class)
+                if (inferred is astroid.YES or
+                        isinstance(inferred, astroid.ClassDef)
                         and inherit_from_std_ex(inferred)):
                     emit = False
             if emit:
@@ -203,26 +244,21 @@ class ExceptionsChecker(BaseChecker):
                                  node=node,
                                  args=expr.name)
         elif ((isinstance(expr, astroid.Name) and expr.name == 'NotImplemented')
-              or (isinstance(expr, astroid.CallFunc) and
+              or (isinstance(expr, astroid.Call) and
                   isinstance(expr.func, astroid.Name) and
                   expr.func.name == 'NotImplemented')):
             self.add_message('notimplemented-raised', node=node)
-        elif isinstance(expr, (Instance, astroid.Class)):
-            if isinstance(expr, Instance):
+        elif isinstance(expr, (astroid.Instance, astroid.ClassDef)):
+            if isinstance(expr, astroid.Instance):
                 # pylint: disable=protected-access
                 expr = expr._proxied
-            if (isinstance(expr, astroid.Class) and
-                    not inherit_from_std_ex(expr)):
+            if (isinstance(expr, astroid.ClassDef) and
+                    not inherit_from_std_ex(expr) and
+                    has_known_bases(expr)):
                 if expr.newstyle:
                     self.add_message('raising-non-exception', node=node)
                 else:
-                    if has_known_bases(expr):
-                        confidence = INFERENCE
-                    else:
-                        confidence = INFERENCE_FAILURE
-                    self.add_message(
-                        'nonstandard-exception', node=node,
-                        confidence=confidence)
+                    self.add_message('nonstandard-exception', node=node)
             else:
                 value_found = False
         else:
@@ -240,7 +276,7 @@ class ExceptionsChecker(BaseChecker):
                    for node in inferred):
                 return
 
-        if not isinstance(exc, astroid.Class):
+        if not isinstance(exc, astroid.ClassDef):
             # Don't emit the warning if the infered stmt
             # is None, but the exception handler is something else,
             # maybe it was redefined.
@@ -261,25 +297,22 @@ class ExceptionsChecker(BaseChecker):
                                  node=handler.type,
                                  args=(part.as_string(), ))
             return
+
         if (not inherit_from_std_ex(exc) and
-                exc.root().name != BUILTINS_NAME):
+                exc.name not in self.builtin_exceptions):
             if has_known_bases(exc):
                 self.add_message('catching-non-exception',
                                  node=handler.type,
                                  args=(exc.name, ))
 
-    @check_messages('bare-except', 'broad-except', 'pointless-except',
+    @check_messages('bare-except', 'broad-except',
                     'binary-op-exception', 'bad-except-order',
-                    'catching-non-exception')
+                    'catching-non-exception', 'duplicate-except')
     def visit_tryexcept(self, node):
         """check for empty except"""
         exceptions_classes = []
         nb_handlers = len(node.handlers)
         for index, handler in enumerate(node.handlers):
-            # single except doing nothing but "pass" without else clause
-            if is_empty(handler.body) and not node.orelse:
-                self.add_message('pointless-except',
-                                 node=handler.type or handler.body[0])
             if handler.type is None:
                 if not is_raising(handler.body):
                     self.add_message('bare-except', node=handler)
@@ -298,7 +331,7 @@ class ExceptionsChecker(BaseChecker):
                 except astroid.InferenceError:
                     continue
                 for part, exc in excs:
-                    if exc is YES:
+                    if exc is astroid.YES:
                         continue
                     if (isinstance(exc, astroid.Instance)
                             and inherit_from_std_ex(exc)):
@@ -307,11 +340,11 @@ class ExceptionsChecker(BaseChecker):
 
                     self._check_catching_non_exception(handler, exc, part)
 
-                    if not isinstance(exc, astroid.Class):
+                    if not isinstance(exc, astroid.ClassDef):
                         continue
 
                     exc_ancestors = [anc for anc in exc.ancestors()
-                                     if isinstance(anc, astroid.Class)]
+                                     if isinstance(anc, astroid.ClassDef)]
                     for previous_exc in exceptions_classes:
                         if previous_exc in exc_ancestors:
                             msg = '%s is an ancestor class of %s' % (
@@ -324,6 +357,10 @@ class ExceptionsChecker(BaseChecker):
                         self.add_message('broad-except',
                                          args=exc.name, node=handler.type)
 
+                    if exc in exceptions_classes:
+                        self.add_message('duplicate-except',
+                                         args=exc.name, node=handler.type)
+
                 exceptions_classes += [exc for _, exc in excs]