third_party/pylint/checkers/base.py - Issue 741023003: Revert "pylint: upgrade to 1.3.1"

Unified Diff: third_party/pylint/checkers/base.py

Issue 741023003: Revert "pylint: upgrade to 1.3.1" (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/tools/depot_tools

Patch Set: Created 6 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: third_party/pylint/checkers/base.py

diff --git a/third_party/pylint/checkers/base.py b/third_party/pylint/checkers/base.py

index 469aeb8849f1cbb4b3cd3b15f7d62dae9588a5c1..2062ae279dab79cabfcff156e80d41bb487a5102 100644

--- a/third_party/pylint/checkers/base.py

+++ b/third_party/pylint/checkers/base.py

@@ -1,7 +1,6 @@

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

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

# 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

@@ -13,29 +12,18 @@

# 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.

+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

"""basic checker for Python code"""

-import sys

-import astroid

+from logilab import astng

from logilab.common.ureports import Table

-from astroid import are_exclusive, InferenceError

-import astroid.bases

+from logilab.astng import are_exclusive

-from pylint.interfaces import IAstroidChecker

-from pylint.utils import EmptyReport

+from pylint.interfaces import IASTNGChecker

from pylint.reporters import diff_string

-from pylint.checkers import BaseChecker

-from pylint.checkers.utils import (

- check_messages,

- clobber_in_except,

- is_builtin_object,

- is_inside_except,

- overrides_a_method,

- safe_infer,

- get_argument_from_call,

- NoSuchArgumentError,

- )

+from pylint.checkers import BaseChecker, EmptyReport

+from pylint.checkers.utils import check_messages, clobber_in_except, is_inside_except

import re

@@ -46,21 +34,8 @@ 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 system methods

NO_REQUIRED_DOC_RGX = re.compile('__.*__')

-REVERSED_METHODS = (('__getitem__', '__len__'),

- ('__reversed__', ))

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

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

-BAD_FUNCTIONS = ['map', 'filter', 'apply']

-if sys.version_info < (3, 0):

- BAD_FUNCTIONS.append('input')

- BAD_FUNCTIONS.append('file')

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

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

del re

@@ -68,8 +43,8 @@ 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.GenExpr)):

+ if isinstance(parent, (astng.For, astng.ListComp, astng.SetComp,

+ astng.DictComp, astng.GenExpr)):

return True

parent = parent.parent

return False

@@ -86,77 +61,6 @@ def in_nested_list(nested_list, 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.

- 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

-if sys.version_info < (3, 0):

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

-else:

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

-ABC_METHODS = set(('abc.abstractproperty', 'abc.abstractmethod',

- 'abc.abstractclassmethod', 'abc.abstractstaticmethod'))

-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.Getattr) 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.Getattr) and

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

- return 'attr'

- return 'method'

-def decorated_with_abc(func):

- """ Determine if the `func` node is decorated

- with `abc` decorators (abstractmethod et co.)

- """

- if func.decorators:

- for node in func.decorators.nodes:

- try:

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

- except InferenceError:

- continue

- if infered and infered.qname() in ABC_METHODS:

- return True

-def has_abstract_methods(node):

- """ Determine if the given `node` has

- abstract methods, defined with `abc` module.

- """

- return any(decorated_with_abc(meth)

- for meth in node.mymethods())

def report_by_type_stats(sect, stats, old_stats):

"""make a report of

@@ -208,191 +112,115 @@ def redefined_by_decorator(node):

"""

if node.decorators:

for decorator in node.decorators.nodes:

- if (isinstance(decorator, astroid.Getattr) and

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

+ if (isinstance(decorator, astng.Getattr) and

+ decorator.expr.name == node.name):

return True

return False

class _BasicChecker(BaseChecker):

- __implements__ = IAstroidChecker

+ __implements__ = IASTNGChecker

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 with abstract methods instantiated',

- 'abstract-class-instantiated',

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

- 'has abstract methods and is instantiated.',

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

- '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.'),

- }

- @check_messages('function-redefined')

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

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

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

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

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

+ return value.'),

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

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

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

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

+ 'E0104': ('Return outside function',

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

+ 'method.'),

+ 'E0105': ('Yield outside function',

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

+ 'method.'),

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

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

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

+ '"yield" statements).'),

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

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

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

+ }

+ def __init__(self, linter):

+ _BasicChecker.__init__(self, linter)

+ @check_messages('E0102')

def visit_class(self, node):

self._check_redefinition('class', node)

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

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

- 'duplicate-argument-name')

+ @check_messages('E0100', 'E0101', 'E0102', 'E0106')

def visit_function(self, 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.Function, astroid.Class))

+ returns = node.nodes_of_class(astng.Return,

+ skip_klass=(astng.Function, astng.Class))

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

if node.is_generator():

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

+ self.add_message('E0100', 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 (v is None or

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

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

- )]:

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

+ if [v for v in values if not (v is None or

+ (isinstance(v, astng.Const) and v.value is None)

+ or (isinstance(v, astng.Name) and v.name == 'None'))]:

+ self.add_message('E0101', 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)

+ for retnode in returns:

+ if isinstance(retnode.value, astng.Const) and \

+ retnode.value.value is not None:

+ self.add_message('E0106', node=node,

+ line=retnode.fromlineno)

- @check_messages('return-outside-function')

+ @check_messages('E0104')

def visit_return(self, node):

- if not isinstance(node.frame(), astroid.Function):

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

+ if not isinstance(node.frame(), astng.Function):

+ self.add_message('E0104', node=node)

- @check_messages('yield-outside-function')

+ @check_messages('E0105')

def visit_yield(self, node):

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

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

+ if not isinstance(node.frame(), astng.Function):

+ self.add_message('E0105', node=node)

- @check_messages('not-in-loop')

+ @check_messages('E0103')

def visit_continue(self, node):

self._check_in_loop(node, 'continue')

- @check_messages('not-in-loop')

+ @check_messages('E0103')

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')

+ @check_messages('E0107')

def visit_unaryop(self, node):

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

+ """check use of the non-existent ++ adn -- 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)

- @check_messages('abstract-class-instantiated')

- def visit_callfunc(self, node):

- """ Check instantiating abstract class with

- abc.ABCMeta as metaclass.

- """

- try:

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

- except astroid.InferenceError:

- return

- if not isinstance(infered, astroid.Class):

- return

- # __init__ was called

- metaclass = infered.metaclass()

- 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

- has_abstract_methods(infered)):

- self.add_message('abstract-class-instantiated', node=node)

- break

- return

- if (metaclass.qname() == 'abc.ABCMeta' and

- has_abstract_methods(infered)):

- self.add_message('abstract-class-instantiated', 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)

+ isinstance(node.operand, astng.UnaryOp) and

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

+ self.add_message('E0107', node=node, args=node.op*2)

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 isinstance(_node, (astng.For, astng.While)):

break

_node = _node.parent

else:

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

+ self.add_message('E0103', 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,

+ self.add_message('E0102', node=node,

args=(redeftype, defined_self.fromlineno))

@@ -400,6 +228,7 @@ class BasicErrorChecker(_BasicChecker):

class BasicChecker(_BasicChecker):

"""checks for :

* doc strings

+ * modules / classes / functions / methods / arguments / variables name

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

functions, methods

* required module attributes

@@ -408,92 +237,60 @@ functions, methods

* uses of the global statement

"""

- __implements__ = IAstroidChecker

+ __implements__ = IASTNGChecker

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 %r',

- '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.'),

- 'W0142': ('Used * or ** magic',

- 'star-args',

- 'Used when a function or method is called using `*args` or '

- '`**kwargs` to dispatch arguments. This doesn\'t improve '

- 'readability and should be used with care.'),

- '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.'),

- 'W0121': ('Use raise ErrorClass(args) instead of raise ErrorClass, args.',

- 'old-raise-syntax',

- "Used when the alternate raise syntax 'raise foo, bar' is used "

- "instead of 'raise foo(bar)'.",

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

- 'C0121': ('Missing required attribute "%s"', # W0103

- 'missing-module-attribute',

- 'Used when an attribute required for modules is missing.'),

- 'E0109': ('Missing argument to reversed()',

- 'missing-reversed-argument',

- 'Used when reversed() builtin didn\'t receive an argument.'),

- '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__'),

+ 'W0101': ('Unreachable code',

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

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

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

+ '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',

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

+ any effect.'),

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

+ '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',

+ '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',

+ '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",

+ "Used when a dictionary expression binds the same key multiple \

+ times."),

+ 'W0122': ('Use of the exec statement',

+ 'Used when you use the "exec" statement, to discourage its \

+ usage. That doesn\'t mean you can not use it !'),

+ 'W0141': ('Used builtin function %r',

+ '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.'),

+ 'W0142': ('Used * or ** magic',

+ 'Used when a function or method is called using `*args` or '

+ '`**kwargs` to dispatch arguments. This doesn\'t improve '

+ 'readability and should be used with care.'),

+ 'W0150': ("%s statement in finally block may swallow 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\'?',

+ '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.'),

+ 'C0121': ('Missing required attribute "%s"', # W0103

+ 'Used when an attribute required for modules is missing.'),

}

@@ -502,15 +299,15 @@ functions, methods

'metavar' : '<attributes>',

'help' : 'Required attributes for module, separated by a '

'comma'}

- ),

+ ),

('bad-functions',

- {'default' : BAD_FUNCTIONS,

+ {'default' : ('map', 'filter', 'apply', 'input'),

'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),)

+ ),

+ )

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

def __init__(self, linter):

_BasicChecker.__init__(self, linter)

@@ -523,14 +320,14 @@ functions, methods

self._tryfinallys = []

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

method=0, class_=0)

- @check_messages('missing-module-attribute')

def visit_module(self, node):

"""check module name, docstring and required arguments

"""

self.stats['module'] += 1

for attr in self.config.required_attributes:

if attr not in node:

- self.add_message('missing-module-attribute', node=node, args=attr)

+ self.add_message('C0121', node=node, args=attr)

def visit_class(self, node):

"""check module name, docstring and redefinition

@@ -538,45 +335,31 @@ functions, methods

"""

self.stats['class'] += 1

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

- 'expression-not-assigned')

+ @check_messages('W0104', 'W0105')

def visit_discard(self, node):

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

expr = node.value

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

- basestring):

+ if isinstance(expr, astng.Const) and isinstance(expr.value,

+ basestring):

# 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.Class, astroid.Module, astroid.Function)):

- if isinstance(scope, astroid.Function) 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)

+ self.add_message('W0105', 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.CallFunc)) or

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

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

+ # side effects), else W0104

+ if (isinstance(expr, (astng.Yield, astng.CallFunc)) or

+ (isinstance(node.parent, astng.TryExcept) and

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

return

- if any(expr.nodes_of_class(astroid.CallFunc)):

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

- args=expr.as_string())

+ if any(expr.nodes_of_class(astng.CallFunc)):

+ self.add_message('W0106', node=node, args=expr.as_string())

else:

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

+ self.add_message('W0104', node=node)

- @check_messages('unnecessary-lambda')

+ @check_messages('W0108')

def visit_lambda(self, node):

"""check whether or not the lambda is suspicious

"""

@@ -591,11 +374,11 @@ functions, methods

# of the lambda.

return

call = node.body

- if not isinstance(call, astroid.CallFunc):

+ if not isinstance(call, astng.CallFunc):

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

# for the lambda to be unnecessary.

return

- # XXX are lambda still different with astroid >= 0.18 ?

+ # XXX are lambda still different with astng >= 0.18 ?

# *args and **kwargs need to be treated specially, since they

# are structured differently between the lambda and the function

# call (in the lambda they appear in the args.args list and are

@@ -605,15 +388,15 @@ functions, methods

ordinary_args = list(node.args.args)

if node.args.kwarg:

if (not call.kwargs

- or not isinstance(call.kwargs, astroid.Name)

- or node.args.kwarg != call.kwargs.name):

+ or not isinstance(call.kwargs, astng.Name)

+ or node.args.kwarg != call.kwargs.name):

return

elif call.kwargs:

return

if node.args.vararg:

if (not call.starargs

- or not isinstance(call.starargs, astroid.Name)

- or node.args.vararg != call.starargs.name):

+ or not isinstance(call.starargs, astng.Name)

+ or node.args.vararg != call.starargs.name):

return

elif call.starargs:

return

@@ -622,18 +405,12 @@ functions, methods

if len(ordinary_args) != len(call.args):

return

for i in xrange(len(ordinary_args)):

- if not isinstance(call.args[i], astroid.Name):

+ if not isinstance(call.args[i], astng.Name):

return

if node.args.args[i].name != call.args[i].name:

return

- if (isinstance(node.body.func, astroid.Getattr) and

- isinstance(node.body.func.expr, astroid.CallFunc)):

- # Chained call, the intermediate call might

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

- return

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

+ self.add_message('W0108', line=node.fromlineno, node=node)

- @check_messages('dangerous-default-value')

def visit_function(self, node):

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

variable names, max locals

@@ -643,20 +420,16 @@ functions, methods

for default in node.args.defaults:

try:

value = default.infer().next()

- except astroid.InferenceError:

+ except astng.InferenceError:

continue

- builtins = astroid.bases.BUILTINS

- if (isinstance(value, astroid.Instance) and

- value.qname() in ['.'.join([builtins, x]) for x in ('set', 'dict', 'list')]):

+ if isinstance(value, (astng.Dict, astng.List)):

if value is default:

msg = default.as_string()

- elif type(value) is astroid.Instance:

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

else:

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

- self.add_message('dangerous-default-value', node=node, args=(msg,))

+ self.add_message('W0102', node=node, args=(msg,))

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

+ @check_messages('W0101', 'W0150')

def visit_return(self, node):

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

unreachable code)

@@ -665,16 +438,16 @@ functions, methods

"""

self._check_unreachable(node)

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

- self._check_not_in_finally(node, 'return', (astroid.Function,))

+ self._check_not_in_finally(node, 'return', (astng.Function,))

- @check_messages('unreachable')

+ @check_messages('W0101')

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')

+ @check_messages('W0101', 'W0150')

def visit_break(self, node):

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

unreachable code)

@@ -684,48 +457,36 @@ functions, methods

# 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,))

+ self._check_not_in_finally(node, 'break', (astng.For, astng.While,))

- @check_messages('unreachable', 'old-raise-syntax')

+ @check_messages('W0101')

def visit_raise(self, node):

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

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

code)

"""

self._check_unreachable(node)

- if sys.version_info >= (3, 0):

- return

- if node.exc is not None and node.inst is not None and node.tback is None:

- self.add_message('old-raise-syntax', node=node)

- @check_messages('exec-used')

+ @check_messages('W0122')

def visit_exec(self, node):

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

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

+ self.add_message('W0122', node=node)

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

- 'exec-used', 'missing-reversed-argument',

- 'bad-reversed-sequence')

+ @check_messages('W0141', 'W0142')

def visit_callfunc(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):

+ if isinstance(node.func, astng.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:

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

+ self.add_message('W0141', node=node, args=name)

if node.starargs or node.kwargs:

scope = node.scope()

- if isinstance(scope, astroid.Function):

+ if isinstance(scope, astng.Function):

toprocess = [(n, vn) for (n, vn) in ((node.starargs, scope.args.vararg),

(node.kwargs, scope.args.kwarg)) if n]

if toprocess:

@@ -733,25 +494,25 @@ functions, methods

if getattr(cfnode, 'name', None) == fargname:

toprocess.remove((cfnode, fargname))

if not toprocess:

- return # star-args can be skipped

- self.add_message('star-args', node=node.func)

+ return # W0142 can be skipped

+ self.add_message('W0142', node=node.func)

- @check_messages('assert-on-tuple')

+ @check_messages('W0199')

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)

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

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

+ self.add_message('W0199', line=node.fromlineno, node=node)

- @check_messages('duplicate-key')

+ @check_messages('W0109')

def visit_dict(self, node):

"""check duplicate key in dictionary"""

keys = set()

- for k, _ in node.items:

- if isinstance(k, astroid.Const):

+ for k, v in node.items:

+ if isinstance(k, astng.Const):

key = k.value

if key in keys:

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

+ self.add_message('W0109', node=node, args=key)

keys.add(key)

def visit_tryfinally(self, node):

@@ -766,7 +527,7 @@ functions, methods

"""check unreachable code"""

unreach_stmt = node.next_sibling()

if unreach_stmt is not None:

- self.add_message('unreachable', node=unreach_stmt)

+ self.add_message('W0101', node=unreach_stmt)

def _check_not_in_finally(self, node, node_name, breaker_classes=()):

"""check that a node is not inside a finally clause of a

@@ -781,132 +542,91 @@ functions, methods

_node = node

while _parent and not isinstance(_parent, breaker_classes):

if hasattr(_parent, 'finalbody') and _node in _parent.finalbody:

- self.add_message('lost-exception', node=node, args=node_name)

+ self.add_message('W0150', node=node, args=node_name)

return

_node = _parent

_parent = _node.parent

- def _check_reversed(self, node):

- """ check that the argument to `reversed` is a sequence """

- try:

- argument = safe_infer(get_argument_from_call(node, position=0))

- except NoSuchArgumentError:

- self.add_message('missing-reversed-argument', node=node)

- else:

- if argument is astroid.YES:

- return

- if argument is None:

- # nothing was infered

- # try to see if we have iter()

- if isinstance(node.args[0], astroid.CallFunc):

- try:

- func = node.args[0].func.infer().next()

- except InferenceError:

- return

- if (getattr(func, 'name', None) == 'iter' and

- is_builtin_object(func)):

- self.add_message('bad-reversed-sequence', node=node)

- return

- if isinstance(argument, astroid.Instance):

- if (argument._proxied.name == 'dict' and

- is_builtin_object(argument._proxied)):

- self.add_message('bad-reversed-sequence', node=node)

- return

- elif any(ancestor.name == 'dict' and is_builtin_object(ancestor)

- for ancestor in argument._proxied.ancestors()):

- # mappings aren't accepted by reversed()

- self.add_message('bad-reversed-sequence', node=node)

- return

- for methods in REVERSED_METHODS:

- for meth in methods:

- try:

- argument.getattr(meth)

- except astroid.NotFoundError:

- break

- else:

- break

- else:

- # check if it is a .deque. It doesn't seem that

- # we can retrieve special methods

- # from C implemented constructs

- if argument._proxied.qname().endswith(".deque"):

- return

- self.add_message('bad-reversed-sequence', node=node)

- elif not isinstance(argument, (astroid.List, astroid.Tuple)):

- # everything else is not a proper sequence for reversed()

- self.add_message('bad-reversed-sequence', node=node)

-_NAME_TYPES = {

- 'module': (MOD_NAME_RGX, 'module'),

- 'const': (CONST_NAME_RGX, 'constant'),

- 'class': (CLASS_NAME_RGX, 'class'),

- 'function': (DEFAULT_NAME_RGX, 'function'),

- 'method': (DEFAULT_NAME_RGX, 'method'),

- 'attr': (DEFAULT_NAME_RGX, 'attribute'),

- 'argument': (DEFAULT_NAME_RGX, 'argument'),

- 'variable': (DEFAULT_NAME_RGX, 'variable'),

- 'class_attribute': (CLASS_ATTRIBUTE_RGX, 'class attribute'),

- 'inlinevar': (COMP_VAR_RGX, 'inline iteration'),

-def _create_naming_options():

- name_options = []

- for name_type, (rgx, human_readable_name) in _NAME_TYPES.iteritems():

- name_type = name_type.replace('_', '-')

- name_options.append((

- '%s-rgx' % (name_type,),

- {'default': rgx, 'type': 'regexp', 'metavar': '<regexp>',

- 'help': 'Regular expression matching correct %s names' % (human_readable_name,)}))

- name_options.append((

- '%s-name-hint' % (name_type,),

- {'default': rgx.pattern, 'type': 'string', 'metavar': '<string>',

- 'help': 'Naming hint for %s names' % (human_readable_name,)}))

- return tuple(name_options)

class NameChecker(_BasicChecker):

msgs = {

- 'C0102': ('Black listed name "%s"',

- 'blacklisted-name',

- 'Used when the name is listed in the black list (unauthorized '

- 'names).'),

- 'C0103': ('Invalid %s name "%s"%s',

- 'invalid-name',

- 'Used when the name doesn\'t match the regular expression '

- 'associated to its type (constant, variable, class...).'),

- }

+ 'C0102': ('Black listed name "%s"',

+ 'Used when the name is listed in the black list (unauthorized \

+ names).'),

+ 'C0103': ('Invalid name "%s" (should match %s)',

+ 'Used when the name doesn\'t match the regular expression \

+ associated to its type (constant, variable, class...).'),

- options = (('good-names',

+ }

+ options = (('module-rgx',

+ {'default' : MOD_NAME_RGX,

+ 'type' :'regexp', 'metavar' : '<regexp>',