Application: gvSIG desktop » gvSIG scripting

# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).

# http://www.logilab.fr/ -- mailto:contact@logilab.fr

# Copyright (c) 2009-2010 Arista Networks, Inc.

#

# This program is free software; you can redistribute it and/or modify it under

# the terms of the GNU General Public License as published by the Free Software

# Foundation; either version 2 of the License, or (at your option) any later

# version.

#

# This program 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License along with

# this program; if not, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

"""basic checker for Python code"""

import collections

import itertools

import sys

import re

import six

from six.moves import zip  # pylint: disable=redefined-builtin

import astroid

import astroid.bases

import astroid.scoped_nodes

from astroid import are_exclusive, InferenceError

from pylint.interfaces import (IAstroidChecker, ITokenChecker, INFERENCE,

                               INFERENCE_FAILURE, HIGH)

from pylint.utils import EmptyReport, deprecated_option

from pylint.reporters import diff_string

from pylint.checkers import BaseChecker, BaseTokenChecker

from pylint.checkers.utils import (

    check_messages,

    clobber_in_except,

    is_builtin_object,

    is_inside_except,

    overrides_a_method,

    get_argument_from_call,

    node_frame_class,

    NoSuchArgumentError,

    error_of_type,

    unimplemented_abstract_methods,

    has_known_bases,

    safe_infer

    )

from pylint.reporters.ureports.nodes import Table

# regex for class/function/variable/constant name

CLASS_NAME_RGX = re.compile('[A-Z_][a-zA-Z0-9]+$')

MOD_NAME_RGX = re.compile('(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$')

CONST_NAME_RGX = re.compile('(([A-Z_][A-Z0-9_]*)|(__.*__))$')

COMP_VAR_RGX = re.compile('[A-Za-z_][A-Za-z0-9_]*$')

DEFAULT_NAME_RGX = re.compile('[a-z_][a-z0-9_]{2,30}$')

CLASS_ATTRIBUTE_RGX = re.compile(r'([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$')

# do not require a doc string on private/system methods

NO_REQUIRED_DOC_RGX = re.compile('^_')

REVERSED_PROTOCOL_METHOD = '__reversed__'

SEQUENCE_PROTOCOL_METHODS = ('__getitem__', '__len__')

REVERSED_METHODS = (SEQUENCE_PROTOCOL_METHODS,

                    (REVERSED_PROTOCOL_METHOD, ))

TYPECHECK_COMPARISON_OPERATORS = frozenset(('is', 'is not', '==',

                                            '!=', 'in', 'not in'))

LITERAL_NODE_TYPES = (astroid.Const, astroid.Dict, astroid.List, astroid.Set)

UNITTEST_CASE = 'unittest.case'

BUILTINS = six.moves.builtins.__name__

TYPE_QNAME = "%s.type" % BUILTINS

PY33 = sys.version_info >= (3, 3)

PY3K = sys.version_info >= (3, 0)

PY35 = sys.version_info >= (3, 5)

BAD_FUNCTIONS = ['map', 'filter']

if sys.version_info < (3, 0):

    BAD_FUNCTIONS.append('input')

# Some hints regarding the use of bad builtins.

BUILTIN_HINTS = {

    'map': 'Using a list comprehension can be clearer.',

}

BUILTIN_HINTS['filter'] = BUILTIN_HINTS['map']

# Name categories that are always consistent with all naming conventions.

EXEMPT_NAME_CATEGORIES = set(('exempt', 'ignore'))

# A mapping from builtin-qname -> symbol, to be used when generating messages

# about dangerous default values as arguments

DEFAULT_ARGUMENT_SYMBOLS = dict(

    zip(['.'.join([BUILTINS, x]) for x in ('set', 'dict', 'list')],

        ['set()', '{}', '[]'])

)

REVERSED_COMPS = {'<': '>', '<=': '>=', '>': '<', '>=': '<='}

del re

def _redefines_import(node):

    """ Detect that the given node (AssName) is inside an

    exception handler and redefines an import from the tryexcept body.

    Returns True if the node redefines an import, False otherwise.

    """

    current = node

    while current and not isinstance(current.parent, astroid.ExceptHandler):

        current = current.parent

    if not current or not error_of_type(current.parent, ImportError):

        return False

    try_block = current.parent.parent

    for import_node in try_block.nodes_of_class((astroid.ImportFrom, astroid.Import)):

        for name, alias in import_node.names:

            if alias:

                if alias == node.name:

                    return True

            elif name == node.name:

                return True

    return False

def in_loop(node):

    """return True if the node is inside a kind of for loop"""

    parent = node.parent

    while parent is not None:

        if isinstance(parent, (astroid.For, astroid.ListComp, astroid.SetComp,

                               astroid.DictComp, astroid.GeneratorExp)):

            return True

        parent = parent.parent

    return False

def in_nested_list(nested_list, obj):

    """return true if the object is an element of <nested_list> or of a nested

    list

    """

    for elmt in nested_list:

        if isinstance(elmt, (list, tuple)):

            if in_nested_list(elmt, obj):

                return True

        elif elmt == obj:

            return True

    return False

def _loop_exits_early(loop):

    """Returns true if a loop has a break statement in its body."""

    loop_nodes = (astroid.For, astroid.While)

    # Loop over body explicitly to avoid matching break statements

    # in orelse.

    for child in loop.body:

        if isinstance(child, loop_nodes):

            # break statement may be in orelse of child loop.

            # pylint: disable=superfluous-parens

            for orelse in (child.orelse or ()):

                for _ in orelse.nodes_of_class(astroid.Break, skip_klass=loop_nodes):

                    return True

            continue

        for _ in child.nodes_of_class(astroid.Break, skip_klass=loop_nodes):

            return True

    return False

def _is_multi_naming_match(match, node_type, confidence):

    return (match is not None and

            match.lastgroup is not None and

            match.lastgroup not in EXEMPT_NAME_CATEGORIES

            and (node_type != 'method' or confidence != INFERENCE_FAILURE))

if sys.version_info < (3, 0):

    PROPERTY_CLASSES = set(('__builtin__.property', 'abc.abstractproperty'))

else:

    PROPERTY_CLASSES = set(('builtins.property', 'abc.abstractproperty'))

def _determine_function_name_type(node):

    """Determine the name type whose regex the a function's name should match.

    :param node: A function node.

    :returns: One of ('function', 'method', 'attr')

    """

    if not node.is_method():

        return 'function'

    if node.decorators:

        decorators = node.decorators.nodes

    else:

        decorators = []

    for decorator in decorators:

        # If the function is a property (decorated with @property

        # or @abc.abstractproperty), the name type is 'attr'.

        if (isinstance(decorator, astroid.Name) or

                (isinstance(decorator, astroid.Attribute) and

                 decorator.attrname == 'abstractproperty')):

            infered = safe_infer(decorator)

            if infered and infered.qname() in PROPERTY_CLASSES:

                return 'attr'

        # If the function is decorated using the prop_method.{setter,getter}

        # form, treat it like an attribute as well.

        elif (isinstance(decorator, astroid.Attribute) and

              decorator.attrname in ('setter', 'deleter')):

            return 'attr'

    return 'method'

def _is_none(node):

    return (node is None or

            (isinstance(node, astroid.Const) and node.value is None) or

            (isinstance(node, astroid.Name)  and node.name == 'None')

           )

def _has_abstract_methods(node):

    """

    Determine if the given `node` has abstract methods.

    The methods should be made abstract by decorating them

    with `abc` decorators.

    """

    return len(unimplemented_abstract_methods(node)) > 0

def report_by_type_stats(sect, stats, old_stats):

    """make a report of

    * percentage of different types documented

    * percentage of different types with a bad name

    """

    # percentage of different types documented and/or with a bad name

    nice_stats = {}

    for node_type in ('module', 'class', 'method', 'function'):

        try:

            total = stats[node_type]

        except KeyError:

            raise EmptyReport()

        nice_stats[node_type] = {}

        if total != 0:

            try:

                documented = total - stats['undocumented_'+node_type]

                percent = (documented * 100.) / total

                nice_stats[node_type]['percent_documented'] = '%.2f' % percent

            except KeyError:

                nice_stats[node_type]['percent_documented'] = 'NC'

            try:

                percent = (stats['badname_'+node_type] * 100.) / total

                nice_stats[node_type]['percent_badname'] = '%.2f' % percent

            except KeyError:

                nice_stats[node_type]['percent_badname'] = 'NC'

    lines = ('type', 'number', 'old number', 'difference',

             '%documented', '%badname')

    for node_type in ('module', 'class', 'method', 'function'):

        new = stats[node_type]

        old = old_stats.get(node_type, None)

        if old is not None:

            diff_str = diff_string(old, new)

        else:

            old, diff_str = 'NC', 'NC'

        lines += (node_type, str(new), str(old), diff_str,

                  nice_stats[node_type].get('percent_documented', '0'),

                  nice_stats[node_type].get('percent_badname', '0'))

    sect.append(Table(children=lines, cols=6, rheaders=1))

def redefined_by_decorator(node):

    """return True if the object is a method redefined via decorator.

    For example:

        @property

        def x(self): return self._x

        @x.setter

        def x(self, value): self._x = value

    """

    if node.decorators:

        for decorator in node.decorators.nodes:

            if (isinstance(decorator, astroid.Attribute) and

                    getattr(decorator.expr, 'name', None) == node.name):

                return True

    return False

def _node_type(node):

    """Return the inferred type for `node`

    If there is more than one possible type, or if inferred type is YES or None,

    return None

    """

    # check there is only one possible type for the assign node. Else we

    # don't handle it for now

    types = set()

    try:

        for var_type in node.infer():

            if var_type == astroid.YES or _is_none(var_type):

                continue

            types.add(var_type)

            if len(types) > 1:

                return

    except InferenceError:

        return

    return types.pop() if types else None

class _BasicChecker(BaseChecker):

    __implements__ = IAstroidChecker

    name = 'basic'

class BasicErrorChecker(_BasicChecker):

    msgs = {

        'E0100': ('__init__ method is a generator',

                  'init-is-generator',

                  'Used when the special class method __init__ is turned into a '

                  'generator by a yield in its body.'),

        'E0101': ('Explicit return in __init__',

                  'return-in-init',

                  'Used when the special class method __init__ has an explicit '

                  'return value.'),

        'E0102': ('%s already defined line %s',

                  'function-redefined',

                  'Used when a function / class / method is redefined.'),

        'E0103': ('%r not properly in loop',

                  'not-in-loop',

                  'Used when break or continue keywords are used outside a loop.'),

        'E0104': ('Return outside function',

                  'return-outside-function',

                  'Used when a "return" statement is found outside a function or '

                  'method.'),

        'E0105': ('Yield outside function',

                  'yield-outside-function',

                  'Used when a "yield" statement is found outside a function or '

                  'method.'),

        'E0106': ('Return with argument inside generator',

                  'return-arg-in-generator',

                  'Used when a "return" statement with an argument is found '

                  'outside in a generator function or method (e.g. with some '

                  '"yield" statements).',

                  {'maxversion': (3, 3)}),

        'E0107': ("Use of the non-existent %s operator",

                  'nonexistent-operator',

                  "Used when you attempt to use the C-style pre-increment or"

                  "pre-decrement operator -- and ++, which doesn't exist in Python."),

        'E0108': ('Duplicate argument name %s in function definition',

                  'duplicate-argument-name',

                  'Duplicate argument names in function definitions are syntax'

                  ' errors.'),

        'E0110': ('Abstract class %r with abstract methods instantiated',

                  'abstract-class-instantiated',

                  'Used when an abstract class with `abc.ABCMeta` as metaclass '

                  'has abstract methods and is instantiated.'),

        'W0120': ('Else clause on loop without a break statement',

                  'useless-else-on-loop',

                  'Loops should only have an else clause if they can exit early '

                  'with a break statement, otherwise the statements under else '

                  'should be on the same scope as the loop itself.'),

        'E0112': ('More than one starred expression in assignment',

                  'too-many-star-expressions',

                  'Emitted when there are more than one starred '

                  'expressions (`*x`) in an assignment. This is a SyntaxError.',

                  {'minversion': (3, 0)}),

        'E0113': ('Starred assignment target must be in a list or tuple',

                  'invalid-star-assignment-target',

                  'Emitted when a star expression is used as a starred '

                  'assignment target.',

                  {'minversion': (3, 0)}),

        'E0114': ('Can use starred expression only in assignment target',

                  'star-needs-assignment-target',

                  'Emitted when a star expression is not used in an '

                  'assignment target.',

                  {'minversion': (3, 0)}),

        'E0115': ('Name %r is nonlocal and global',

                  'nonlocal-and-global',

                  'Emitted when a name is both nonlocal and global.',

                  {'minversion': (3, 0)}),

        'E0116': ("'continue' not supported inside 'finally' clause",

                  'continue-in-finally',

                  'Emitted when the `continue` keyword is found '

                  'inside a finally clause, which is a SyntaxError.'),

        'E0117': ("nonlocal name %s found without binding",

                  'nonlocal-without-binding',

                  'Emitted when a nonlocal variable does not have an attached '

                  'name somewhere in the parent scopes',

                  {'minversion': (3, 0)}),

        }

    @check_messages('function-redefined')

    def visit_classdef(self, node):

        self._check_redefinition('class', node)

    @check_messages('too-many-star-expressions',

                    'invalid-star-assignment-target')

    def visit_assign(self, node):

        starred = list(node.targets[0].nodes_of_class(astroid.Starred))

        if len(starred) > 1:

            self.add_message('too-many-star-expressions', node=node)

        # Check *a = b

        if isinstance(node.targets[0], astroid.Starred):

            self.add_message('invalid-star-assignment-target', node=node)

    @check_messages('star-needs-assignment-target')

    def visit_starred(self, node):

        """Check that a Starred expression is used in an assignment target."""

        if isinstance(node.parent, astroid.Call):

            # f(*args) is converted to Call(args=[Starred]), so ignore

            # them for this check.

            return

        if PY35 and isinstance(node.parent,

                               (astroid.List, astroid.Tuple,

                                astroid.Set, astroid.Dict)):

            # PEP 448 unpacking.

            return

        stmt = node.statement()

        if not isinstance(stmt, astroid.Assign):

            return

        if stmt.value is node or stmt.value.parent_of(node):

            self.add_message('star-needs-assignment-target', node=node)

    @check_messages('init-is-generator', 'return-in-init',

                    'function-redefined', 'return-arg-in-generator',

                    'duplicate-argument-name', 'nonlocal-and-global')

    def visit_functiondef(self, node):

        self._check_nonlocal_and_global(node)

        if not redefined_by_decorator(node):

            self._check_redefinition(node.is_method() and 'method' or 'function', node)

        # checks for max returns, branch, return in __init__

        returns = node.nodes_of_class(astroid.Return,

                                      skip_klass=(astroid.FunctionDef,

                                                  astroid.ClassDef))

        if node.is_method() and node.name == '__init__':

            if node.is_generator():

                self.add_message('init-is-generator', node=node)

            else:

                values = [r.value for r in returns]

                # Are we returning anything but None from constructors

                if [v for v in values if not _is_none(v)]:

                    self.add_message('return-in-init', node=node)

        elif node.is_generator():

            # make sure we don't mix non-None returns and yields

            if not PY33:

                for retnode in returns:

                    if isinstance(retnode.value, astroid.Const) and \

                           retnode.value.value is not None:

                        self.add_message('return-arg-in-generator', node=node,

                                         line=retnode.fromlineno)

        # Check for duplicate names

        args = set()

        for name in node.argnames():

            if name in args:

                self.add_message('duplicate-argument-name', node=node, args=(name,))

            else:

                args.add(name)

    visit_asyncfunctiondef = visit_functiondef

    def _check_nonlocal_and_global(self, node):

        """Check that a name is both nonlocal and global."""

        def same_scope(current):

            return current.scope() is node

        from_iter = itertools.chain.from_iterable

        nonlocals = set(from_iter(

            child.names for child in node.nodes_of_class(astroid.Nonlocal)

            if same_scope(child)))

        global_vars = set(from_iter(

            child.names for child in node.nodes_of_class(astroid.Global)

            if same_scope(child)))

        for name in nonlocals.intersection(global_vars):

            self.add_message('nonlocal-and-global',

                             args=(name, ), node=node)

    @check_messages('return-outside-function')

    def visit_return(self, node):

        if not isinstance(node.frame(), astroid.FunctionDef):

            self.add_message('return-outside-function', node=node)

    @check_messages('yield-outside-function')

    def visit_yield(self, node):

        self._check_yield_outside_func(node)

    @check_messages('yield-outside-function')

    def visit_yieldfrom(self, node):

        self._check_yield_outside_func(node)

    @check_messages('not-in-loop', 'continue-in-finally')

    def visit_continue(self, node):

        self._check_in_loop(node, 'continue')

    @check_messages('not-in-loop')

    def visit_break(self, node):

        self._check_in_loop(node, 'break')

    @check_messages('useless-else-on-loop')

    def visit_for(self, node):

        self._check_else_on_loop(node)

    @check_messages('useless-else-on-loop')

    def visit_while(self, node):

        self._check_else_on_loop(node)

    @check_messages('nonexistent-operator')

    def visit_unaryop(self, node):

        """check use of the non-existent ++ and -- operator operator"""

        if ((node.op in '+-') and

                isinstance(node.operand, astroid.UnaryOp) and

                (node.operand.op == node.op)):

            self.add_message('nonexistent-operator', node=node, args=node.op*2)

    def _check_nonlocal_without_binding(self, node, name):

        current_scope = node.scope()

        while True:

            if current_scope.parent is None:

                break

            if not isinstance(current_scope, astroid.FunctionDef):

                self.add_message('nonlocal-without-binding', args=(name, ),

                                 node=node)

                return

            else:

                if name not in current_scope.locals:

                    current_scope = current_scope.parent.scope()

                    continue

                else:

                    # Okay, found it.

                    return

        self.add_message('nonlocal-without-binding', args=(name, ), node=node)

    @check_messages('nonlocal-without-binding')

    def visit_nonlocal(self, node):

        for name in node.names:

            self._check_nonlocal_without_binding(node, name)

    @check_messages('abstract-class-instantiated')

    def visit_call(self, node):

        """ Check instantiating abstract class with

        abc.ABCMeta as metaclass.

        """

        try:

            infered = next(node.func.infer())

        except astroid.InferenceError:

            return

        if not isinstance(infered, astroid.ClassDef):

            return

        klass = node_frame_class(node)

        if klass is infered:

            # Don't emit the warning if the class is instantiated

            # in its own body or if the call is not an instance

            # creation. If the class is instantiated into its own

            # body, we're expecting that it knows what it is doing.

            return

        # __init__ was called

        metaclass = infered.metaclass()

        abstract_methods = _has_abstract_methods(infered)

        if metaclass is None:

            # Python 3.4 has `abc.ABC`, which won't be detected

            # by ClassNode.metaclass()

            for ancestor in infered.ancestors():

                if ancestor.qname() == 'abc.ABC' and abstract_methods:

                    self.add_message('abstract-class-instantiated',

                                     args=(infered.name, ),

                                     node=node)

                    break

            return

        if metaclass.qname() == 'abc.ABCMeta' and abstract_methods:

            self.add_message('abstract-class-instantiated',

                             args=(infered.name, ),

                             node=node)

    def _check_yield_outside_func(self, node):

        if not isinstance(node.frame(), (astroid.FunctionDef, astroid.Lambda)):

            self.add_message('yield-outside-function', node=node)

    def _check_else_on_loop(self, node):

        """Check that any loop with an else clause has a break statement."""

        if node.orelse and not _loop_exits_early(node):

            self.add_message('useless-else-on-loop', node=node,

                             # This is not optimal, but the line previous

                             # to the first statement in the else clause

                             # will usually be the one that contains the else:.

                             line=node.orelse[0].lineno - 1)

    def _check_in_loop(self, node, node_name):

        """check that a node is inside a for or while loop"""

        _node = node.parent

        while _node:

            if isinstance(_node, (astroid.For, astroid.While)):

                if node not in _node.orelse:

                    return

            if isinstance(_node, (astroid.ClassDef, astroid.FunctionDef)):

                break

            if (isinstance(_node, astroid.TryFinally)

                    and node in _node.finalbody

                    and isinstance(node, astroid.Continue)):

                self.add_message('continue-in-finally', node=node)

            _node = _node.parent

        self.add_message('not-in-loop', node=node, args=node_name)

    def _check_redefinition(self, redeftype, node):

        """check for redefinition of a function / method / class name"""

        defined_self = node.parent.frame()[node.name]

        if defined_self is not node and not are_exclusive(node, defined_self):

            self.add_message('function-redefined', node=node,

                             args=(redeftype, defined_self.fromlineno))

class BasicChecker(_BasicChecker):

    """checks for :

    * doc strings

    * number of arguments, local variables, branches, returns and statements in

functions, methods

    * required module attributes

    * dangerous default values as arguments

    * redefinition of function / method / class

    * uses of the global statement

    """

    __implements__ = IAstroidChecker

    name = 'basic'

    msgs = {

        'W0101': ('Unreachable code',

                  'unreachable',

                  'Used when there is some code behind a "return" or "raise" '

                  'statement, which will never be accessed.'),

        'W0102': ('Dangerous default value %s as argument',

                  'dangerous-default-value',

                  'Used when a mutable value as list or dictionary is detected in '

                  'a default value for an argument.'),

        'W0104': ('Statement seems to have no effect',

                  'pointless-statement',

                  'Used when a statement doesn\'t have (or at least seems to) '

                  'any effect.'),

        'W0105': ('String statement has no effect',

                  'pointless-string-statement',

                  'Used when a string is used as a statement (which of course '

                  'has no effect). This is a particular case of W0104 with its '

                  'own message so you can easily disable it if you\'re using '

                  'those strings as documentation, instead of comments.'),

        'W0106': ('Expression "%s" is assigned to nothing',

                  'expression-not-assigned',

                  'Used when an expression that is not a function call is assigned '

                  'to nothing. Probably something else was intended.'),

        'W0108': ('Lambda may not be necessary',

                  'unnecessary-lambda',

                  'Used when the body of a lambda expression is a function call '

                  'on the same argument list as the lambda itself; such lambda '

                  'expressions are in all but a few cases replaceable with the '

                  'function being called in the body of the lambda.'),

        'W0109': ("Duplicate key %r in dictionary",

                  'duplicate-key',

                  'Used when a dictionary expression binds the same key multiple '

                  'times.'),

        'W0122': ('Use of exec',

                  'exec-used',

                  'Used when you use the "exec" statement (function for Python '

                  '3), to discourage its usage. That doesn\'t '

                  'mean you can not use it !'),

        'W0123': ('Use of eval',

                  'eval-used',

                  'Used when you use the "eval" function, to discourage its '

                  'usage. Consider using `ast.literal_eval` for safely evaluating '

                  'strings containing Python expressions '

                  'from untrusted sources. '),

        'W0141': ('Used builtin function %s',

                  'bad-builtin',

                  'Used when a black listed builtin function is used (see the '

                  'bad-function option). Usual black listed functions are the ones '

                  'like map, or filter , where Python offers now some cleaner '

                  'alternative like list comprehension.'),

        'W0150': ("%s statement in finally block may swallow exception",

                  'lost-exception',

                  'Used when a break or a return statement is found inside the '

                  'finally clause of a try...finally block: the exceptions raised '

                  'in the try clause will be silently swallowed instead of being '

                  're-raised.'),

        'W0199': ('Assert called on a 2-uple. Did you mean \'assert x,y\'?',

                  'assert-on-tuple',

                  'A call of assert on a tuple will always evaluate to true if '

                  'the tuple is not empty, and will always evaluate to false if '

                  'it is.'),

        'W0124': ('Following "as" with another context manager looks like a tuple.',

                  'confusing-with-statement',

                  'Emitted when a `with` statement component returns multiple values '

                  'and uses name binding with `as` only for a part of those values, '

                  'as in with ctx() as a, b. This can be misleading, since it\'s not '

                  'clear if the context manager returns a tuple or if the node without '

                  'a name binding is another context manager.'),

        'W0125': ('Using a conditional statement with a constant value',

                  'using-constant-test',

                  'Emitted when a conditional statement (If or ternary if) '

                  'uses a constant value for its test. This might not be what '

                  'the user intended to do.'),

        'E0111': ('The first reversed() argument is not a sequence',

                  'bad-reversed-sequence',

                  'Used when the first argument to reversed() builtin '

                  'isn\'t a sequence (does not implement __reversed__, '

                  'nor __getitem__ and __len__'),

    }

    options = (('required-attributes',

                deprecated_option(opt_type='csv',

                                  help_msg="Required attributes for module. "

                                           "This option is obsolete.")),

               ('bad-functions',

                {'default' : BAD_FUNCTIONS,

                 'type' :'csv', 'metavar' : '<builtin function names>',

                 'help' : 'List of builtins function names that should not be '

                          'used, separated by a comma'}

               ),

              )

    reports = (('RP0101', 'Statistics by type', report_by_type_stats),)

    def __init__(self, linter):

        _BasicChecker.__init__(self, linter)

        self.stats = None

        self._tryfinallys = None

    def open(self):

        """initialize visit variables and statistics

        """

        self._tryfinallys = []

        self.stats = self.linter.add_stats(module=0, function=0,

                                           method=0, class_=0)

    @check_messages('using-constant-test')

    def visit_if(self, node):

        self._check_using_constant_test(node, node.test)

    @check_messages('using-constant-test')

    def visit_ifexp(self, node):

        self._check_using_constant_test(node, node.test)

    @check_messages('using-constant-test')

    def visit_comprehension(self, node):

        if node.ifs:

            for if_test in node.ifs:

                self._check_using_constant_test(node, if_test)

    def _check_using_constant_test(self, node, test):

        const_nodes = (

            astroid.Module,

            astroid.scoped_nodes.GeneratorExp,

            astroid.Lambda, astroid.FunctionDef, astroid.ClassDef,

            astroid.bases.Generator, astroid.UnboundMethod,

            astroid.BoundMethod, astroid.Module)

        structs = (astroid.Dict, astroid.Tuple, astroid.Set)

        # These nodes are excepted, since they are not constant

        # values, requiring a computation to happen. The only type

        # of node in this list which doesn't have this property is

        # Getattr, which is excepted because the conditional statement

        # can be used to verify that the attribute was set inside a class,

        # which is definitely a valid use case.

        except_nodes = (astroid.Attribute, astroid.Call,

                        astroid.BinOp, astroid.BoolOp, astroid.UnaryOp,

                        astroid.Subscript)

        inferred = None

        emit = isinstance(test, (astroid.Const, ) + structs + const_nodes)

        if not isinstance(test, except_nodes):

            inferred = safe_infer(test)

        if emit or isinstance(inferred, const_nodes):

            self.add_message('using-constant-test', node=node)

    def visit_module(self, _):

        """check module name, docstring and required arguments

        """

        self.stats['module'] += 1

    def visit_classdef(self, node): # pylint: disable=unused-argument

        """check module name, docstring and redefinition

        increment branch counter

        """

        self.stats['class'] += 1

    @check_messages('pointless-statement', 'pointless-string-statement',

                    'expression-not-assigned')

    def visit_expr(self, node):

        """check for various kind of statements without effect"""

        expr = node.value

        if isinstance(expr, astroid.Const) and isinstance(expr.value,

                                                          six.string_types):

            # treat string statement in a separated message

            # Handle PEP-257 attribute docstrings.

            # An attribute docstring is defined as being a string right after

            # an assignment at the module level, class level or __init__ level.

            scope = expr.scope()

            if isinstance(scope, (astroid.ClassDef, astroid.Module, astroid.FunctionDef)):

                if isinstance(scope, astroid.FunctionDef) and scope.name != '__init__':

                    pass

                else:

                    sibling = expr.previous_sibling()

                    if (sibling is not None and sibling.scope() is scope and

                            isinstance(sibling, astroid.Assign)):

                        return

            self.add_message('pointless-string-statement', node=node)

            return

        # ignore if this is :

        # * a direct function call

        # * the unique child of a try/except body

        # * a yield (which are wrapped by a discard node in _ast XXX)

        # warn W0106 if we have any underlying function call (we can't predict

        # side effects), else pointless-statement

        if (isinstance(expr, (astroid.Yield, astroid.Await, astroid.Call)) or

                (isinstance(node.parent, astroid.TryExcept) and

                 node.parent.body == [node])):

            return

        if any(expr.nodes_of_class(astroid.Call)):

            self.add_message('expression-not-assigned', node=node,

                             args=expr.as_string())

        else:

            self.add_message('pointless-statement', node=node)

    @staticmethod

    def _filter_vararg(node, call_args):

        # Return the arguments for the given call which are

        # not passed as vararg.

        for arg in call_args:

            if isinstance(arg, astroid.Starred):

                if (isinstance(arg.value, astroid.Name)

                        and arg.value.name != node.args.vararg):

                    yield arg

            else:

                yield arg

    @staticmethod

    def _has_variadic_argument(args, variadic_name):

        if not args:

            return True

        for arg in args:

            if isinstance(arg.value, astroid.Name):

                if arg.value.name != variadic_name:

                    return True

            else:

                return True

        return False

    @check_messages('unnecessary-lambda')

    def visit_lambda(self, node):

        """check whether or not the lambda is suspicious

        """

        # if the body of the lambda is a call expression with the same

        # argument list as the lambda itself, then the lambda is

        # possibly unnecessary and at least suspicious.

        if node.args.defaults:

            # If the arguments of the lambda include defaults, then a

            # judgment cannot be made because there is no way to check

            # that the defaults defined by the lambda are the same as

            # the defaults defined by the function called in the body

            # of the lambda.

            return

        call = node.body

        if not isinstance(call, astroid.Call):

            # The body of the lambda must be a function call expression

            # for the lambda to be unnecessary.

            return

        if (isinstance(node.body.func, astroid.Attribute) and

                isinstance(node.body.func.expr, astroid.Call)):

            # Chained call, the intermediate call might

            # return something else (but we don't check that, yet).

            return

        ordinary_args = list(node.args.args)

        new_call_args = list(self._filter_vararg(node, call.args))

        if node.args.kwarg:

            if self._has_variadic_argument(call.kwargs, node.args.kwarg):

                return

        elif call.kwargs or call.keywords:

            return

        if node.args.vararg:

            if self._has_variadic_argument(call.starargs, node.args.vararg):

                return

        elif call.starargs:

            return

        # The "ordinary" arguments must be in a correspondence such that:

        # ordinary_args[i].name == call.args[i].name.

        if len(ordinary_args) != len(new_call_args):

            return

        for arg, passed_arg in zip(ordinary_args, new_call_args):

            if not isinstance(passed_arg, astroid.Name):

                return

            if arg.name != passed_arg.name:

                return

        self.add_message('unnecessary-lambda', line=node.fromlineno,

                         node=node)

    @check_messages('dangerous-default-value')

    def visit_functiondef(self, node):

        """check function name, docstring, arguments, redefinition,

        variable names, max locals

        """

        self.stats[node.is_method() and 'method' or 'function'] += 1

        self._check_dangerous_default(node)

    visit_asyncfunctiondef = visit_functiondef

    def _check_dangerous_default(self, node):

        # check for dangerous default values as arguments

        is_iterable = lambda n: isinstance(n, (astroid.List,

                                               astroid.Set,

                                               astroid.Dict))

        for default in node.args.defaults:

            try:

                value = next(default.infer())

            except astroid.InferenceError:

                continue

            if (isinstance(value, astroid.Instance) and

                    value.qname() in DEFAULT_ARGUMENT_SYMBOLS):

                if value is default:

                    msg = DEFAULT_ARGUMENT_SYMBOLS[value.qname()]

                elif isinstance(value, astroid.Instance) or is_iterable(value):

                    # We are here in the following situation(s):

                    #   * a dict/set/list/tuple call which wasn't inferred

                    #     to a syntax node ({}, () etc.). This can happen

                    #     when the arguments are invalid or unknown to

                    #     the inference.

                    #   * a variable from somewhere else, which turns out to be a list

                    #     or a dict.

                    if is_iterable(default):

                        msg = value.pytype()

                    elif isinstance(default, astroid.Call):

                        msg = '%s() (%s)' % (value.name, value.qname())

                    else:

                        msg = '%s (%s)' % (default.as_string(), value.qname())

                else:

                    # this argument is a name

                    msg = '%s (%s)' % (default.as_string(),

                                       DEFAULT_ARGUMENT_SYMBOLS[value.qname()])

                self.add_message('dangerous-default-value',

                                 node=node,

                                 args=(msg, ))

    @check_messages('unreachable', 'lost-exception')

    def visit_return(self, node):

        """1 - check is the node has a right sibling (if so, that's some

        unreachable code)

        2 - check is the node is inside the finally clause of a try...finally

        block

        """

        self._check_unreachable(node)

        # Is it inside final body of a try...finally bloc ?

        self._check_not_in_finally(node, 'return', (astroid.FunctionDef,))

    @check_messages('unreachable')

    def visit_continue(self, node):

        """check is the node has a right sibling (if so, that's some unreachable

        code)

        """

        self._check_unreachable(node)

    @check_messages('unreachable', 'lost-exception')

    def visit_break(self, node):

        """1 - check is the node has a right sibling (if so, that's some

        unreachable code)

        2 - check is the node is inside the finally clause of a try...finally

        block

        """

        # 1 - Is it right sibling ?

        self._check_unreachable(node)

        # 2 - Is it inside final body of a try...finally bloc ?

        self._check_not_in_finally(node, 'break', (astroid.For, astroid.While,))

    @check_messages('unreachable')

    def visit_raise(self, node):

        """check if the node has a right sibling (if so, that's some unreachable

        code)

        """

        self._check_unreachable(node)

    @check_messages('exec-used')

    def visit_exec(self, node):

        """just print a warning on exec statements"""

        self.add_message('exec-used', node=node)

    @check_messages('bad-builtin', 'eval-used',

                    'exec-used', 'bad-reversed-sequence')

    def visit_call(self, node):

        """visit a CallFunc node -> check if this is not a blacklisted builtin

        call and check for * or ** use

        """

        if isinstance(node.func, astroid.Name):

            name = node.func.name

            # ignore the name if it's not a builtin (i.e. not defined in the

            # locals nor globals scope)

            if not (name in node.frame() or

                    name in node.root()):

                if name == 'exec':

                    self.add_message('exec-used', node=node)

                elif name == 'reversed':

                    self._check_reversed(node)

                elif name == 'eval':

                    self.add_message('eval-used', node=node)

                if name in self.config.bad_functions:

                    hint = BUILTIN_HINTS.get(name)

                    if hint:

                        args = "%r. %s" % (name, hint)

                    else:

                        args = repr(name)

                    self.add_message('bad-builtin', node=node, args=args)

    @check_messages('assert-on-tuple')

    def visit_assert(self, node):

        """check the use of an assert statement on a tuple."""

        if node.fail is None and isinstance(node.test, astroid.Tuple) and \

                len(node.test.elts) == 2:

            self.add_message('assert-on-tuple', node=node)

    @check_messages('duplicate-key')

    def visit_dict(self, node):

        """check duplicate key in dictionary"""

        keys = set()

        for k, _ in node.items:

            if isinstance(k, astroid.Const):

                key = k.value

                if key in keys:

                    self.add_message('duplicate-key', node=node, args=key)