| from pychecker2.Check import Check |
| from pychecker2.Check import Warning |
| from pychecker2 import symbols |
| from pychecker2.util import * |
| |
| from compiler.misc import mangle |
| from compiler import ast, walk |
| |
| _ignorable = {} |
| for ignore in ['repr', 'dict', 'class', 'doc', 'str']: |
| _ignorable['__%s__' % ignore] = 1 |
| |
| class GetDefs(BaseVisitor): |
| "Record definitions of a attribute of self, who's name is provided" |
| def __init__(self, name): |
| self.selfname = name |
| self.result = {} |
| |
| def visitAssAttr(self, node): |
| if isinstance(node.expr, ast.Name) and \ |
| node.expr.name == self.selfname and \ |
| isinstance(node.parent, (ast.Assign, ast.AssTuple)): |
| self.result[node.attrname] = node |
| |
| def visitClass(self, node): # ignore nested classes |
| pass |
| |
| class GetRefs(BaseVisitor): |
| "Record references to a attribute of self, who's name is provided" |
| def __init__(self, name): |
| self.selfname = name |
| self.result = {} |
| |
| def visitAssAttr(self, node): |
| if isinstance(node.expr, ast.Name) and \ |
| node.expr.name == self.selfname and \ |
| not isinstance(node.parent, (ast.Assign, ast.AssTuple)): |
| self.result[node.attrname] = node |
| self.visitChildren(node) |
| |
| def visitGetattr(self, node): |
| if isinstance(node.expr, ast.Name) and \ |
| node.expr.name == self.selfname: |
| self.result[node.attrname] = node |
| self.visitChildren(node) |
| |
| def visitClass(self, node): # ignore nested classes |
| pass |
| |
| |
| def _get_methods(class_scope): |
| return type_filter(class_scope.get_children(), symbols.FunctionScope) |
| |
| class NotSimpleName(Exception): pass |
| |
| # compress Getattr(Getattr(Name(x), y), z) -> "x.y.z" |
| def get_name(node): |
| if isinstance(node, ast.Getattr): |
| return get_name(node.expr) + (node.attrname, ) |
| elif isinstance(node, ast.Name): |
| return (node.name,) |
| else: |
| raise NotSimpleName |
| |
| def get_base_names(scope): |
| names = [] |
| for b in scope.node.bases: |
| try: |
| names.append(get_name(b)) |
| except NotSimpleName: # FIXME: hiding expressions |
| pass |
| return names |
| |
| def find_in_module(package, remotename, names, checker): |
| # No other names, must be a name from the module |
| if not names: |
| f = checker.check_module(package) |
| if f: |
| return find_scope_going_down(f.root_scope, [remotename], checker) |
| return None |
| |
| # complex name lookup |
| try: |
| # first, get the real name of the package |
| name = package.__name__ |
| module = __import__(name, globals(), {}, ['']) |
| except AttributeError: |
| # ok, so its a fake module... go with that |
| module = package |
| if remotename: |
| name += "." + remotename |
| # now import it, and chase down any other modules |
| submodule = getattr(module, names[0], None) |
| if type(submodule) == type(symbols): |
| return find_in_module(submodule, None, names[1:], checker) |
| |
| # object in the module is not another module, so chase down the source |
| f = checker.check_module(submodule) |
| if f: |
| return find_scope_going_down(f.root_scope, names, checker) |
| return None |
| |
| def find_scope_going_down(scope, names, checker): |
| "Drill down scopes to find definition of x.y.z" |
| for c in scope.get_children(): |
| if getattr(c, 'name', '') == names[0]: |
| if len(names) == 1: |
| return c |
| return find_scope_going_down(c, names[1:], checker) |
| # Not defined here, check for import |
| return find_imported_class(scope.imports, names, checker) |
| |
| def find_imported_class(imports, names, checker): |
| # may be defined by import |
| for i in range(1, len(names) + 1): |
| # try x, then x.y, then x.y.z as imported names |
| try: |
| name = ".".join(names[:i]) |
| ref = imports[name] |
| # now look for the rest of the name |
| result = find_in_module(ref.module, ref.remotename, names[i:], checker) |
| if result: |
| return result |
| except (KeyError, ImportError): |
| pass |
| return None |
| |
| def find_scope_going_up(scope, names, checker): |
| "Search up to find scope defining x of x.y.z" |
| for p in parents(scope): |
| if p.defs.has_key(names[0]): |
| return find_scope_going_down(p, names, checker) |
| # name imported via 'from module import *' |
| try: |
| return find_in_module(p.imports[names[0]].module, None, names, checker) |
| except KeyError: |
| return None |
| |
| def get_base_classes(scope, checker): |
| result = [] |
| for name in get_base_names(scope): |
| base = find_scope_going_up(scope, name, checker) |
| if base: |
| result.append(base) |
| result.extend(get_base_classes(base, checker)) |
| return result |
| |
| def conformsTo(a, b): |
| alen = len(a.node.argnames) |
| blen = len(b.node.argnames) |
| # f(a, *args, **kw) conforms to f(a, b, *args, **kw) |
| # f(a, *args) conforms to f(a, b, *args) |
| # f(a, *args) conforms to f(a, b, c) |
| # f(a, b, c, *args) does not conform to f(a, b) |
| if alen == blen: |
| if a.node.kwargs == b.node.kwargs and a.node.varargs == b.node.varargs: |
| return 1 |
| if a.node.varargs and alen - 1 <= blen: |
| return a.node.kwargs == b.node.kwargs |
| return None |
| |
| class AttributeCheck(Check): |
| "check `self.attr' expressions for attr" |
| |
| unknownAttribute = Warning('Report unknown object attributes in methods', |
| 'Class %s has no attribute %s') |
| unusedAttribute = Warning('Report attributes unused in methods', |
| 'Attribute %s is not used in class %s') |
| methodRedefined = Warning('Report the redefinition of class methods', |
| 'Method %s in class %s redefined') |
| signatureChanged = Warning('Report methods whose signatures do not ' |
| 'match base class methods', |
| 'Signature does not match method ' |
| '%s in base class %s') |
| attributeInitialized = \ |
| Warning('Report attributes not initialized in __init__', |
| 'Attribute %s is not initialized in __init__') |
| |
| def check(self, file, checker): |
| def visit_with_self(Visitor, method): |
| if not method.node.argnames: |
| return {} |
| return walk(method.node, Visitor(method.node.argnames[0])).result |
| |
| # for all class scopes |
| for node, scope in file.class_scopes(): |
| init_attributes = None # attributes initilized in __init__ |
| attributes = {} # "self.foo = " kinda things |
| methods = {} # methods -> scopes |
| |
| # get attributes defined on self |
| for m in _get_methods(scope): |
| defs = visit_with_self(GetDefs, m) |
| if m.name == '__init__': |
| init_attributes = defs |
| attributes.update(defs) |
| methods[mangle(m.name, scope.name)] = m |
| |
| # complain about attributes not initialized in __init__ |
| if init_attributes is not None: |
| for name, node in dict_minus(attributes, init_attributes).items(): |
| file.warning(node, self.attributeInitialized, name) |
| |
| # collect inherited gunk: methods and attributes |
| # check for non-conformant methods |
| inherited_methods = scope.defs.copy() |
| inherited_attributes = attributes.copy() |
| for base in get_base_classes(scope, checker): |
| for m in _get_methods(base): |
| inherited_attributes.update(visit_with_self(GetDefs, m)) |
| mname = mangle(m.name, base.name) |
| if m.name != "__init__" and \ |
| methods.has_key(mname) and \ |
| not conformsTo(methods[mname], m): |
| file.warning(methods[mname].node, |
| self.signatureChanged, m.name, base.name) |
| else: |
| methods[mname] = m |
| inherited_methods.update(base.defs) |
| |
| # complain about attributes with the same name as methods |
| both = dict_intersect(attributes, inherited_methods) |
| for name, node in both.items(): |
| file.warning(node, self.methodRedefined, name, scope.name) |
| |
| # find refs on self |
| refs = {} |
| for m in _get_methods(scope): |
| refs.update(visit_with_self(GetRefs, m)) |
| |
| # Now complain about refs on self that aren't known |
| unknown = dict_minus(refs, inherited_methods) |
| unknown = dict_minus(unknown, _ignorable) |
| unknown = dict_minus(unknown, scope.defs) |
| unknown = dict_minus(unknown, inherited_attributes) |
| for name, node in unknown.items(): |
| file.warning(node, self.unknownAttribute, scope.name, name) |
| |
| unused = dict_minus(attributes, refs) |
| for name, node in unused.items(): |
| if name.startswith('__'): |
| file.warning(node, self.unusedAttribute, name, scope.name) |
| |
| class GetReturns(BaseVisitor): |
| |
| def __init__(self): |
| self.result = [] |
| |
| def visitReturn(self, node): |
| self.result.append(node) |
| |
| def visitFunction(self, node): pass |
| visitClass = visitFunction |
| |
| class InitCheck(Check): |
| |
| initReturnsValue = Warning('Report value returned from __init__', |
| 'Method __init__ should not return a value') |
| |
| def check(self, file, unused_checker): |
| |
| for node, scope in file.class_scopes(): |
| for m in _get_methods(scope): |
| if m.name == '__init__': |
| for r in walk(m.node.code, GetReturns()).result: |
| if isinstance(r.value, ast.Const) and \ |
| r.value.value is None: |
| continue |
| if isinstance(r.value, ast.Name) and \ |
| r.value.name == 'None': |
| continue |
| file.warning(r, self.initReturnsValue) |
| |
| |
| |
| special = { |
| '__cmp__': 2, '__del__': 1, '__delitem__': 2, '__eq__': 2, |
| '__ge__': 2, '__getitem__': 2, '__gt__': 2, '__hash__': 1, |
| '__le__': 2, '__len__': 1, '__lt__': 2, '__ne__': 2, |
| '__nonzero__': 1, '__repr__': 1, '__setitem__': 3, '__str__': 1, |
| '__getattr__': 2, '__setattr__': 3, |
| '__delattr__': 2, '__len__': 1, '__delitem__': 2, '__iter__': 1, |
| '__contains__': 2,'__setslice__': 4,'__delslice__': 3, |
| '__add__': 2, '__sub__': 2, '__mul__': 2, '__floordiv__': 2, |
| '__mod__': 2, '__divmod__': 2, '__lshift__': 2, |
| '__rshift__': 2, '__and__': 2, '__xor__': 2, '__or__': 2, |
| '__div__': 2, '__truediv__': 2, '__radd__': 2, '__rsub__': 2, |
| '__rmul__': 2, '__rdiv__': 2, '__rmod__': 2, '__rdivmod__': 2, |
| '__rpow__': 2, '__rlshift__': 2, '__rrshift__': 2, '__rand__': 2, |
| '__rxor__': 2, '__ror__': 2, '__iadd__': 2, '__isub__': 2, |
| '__imul__': 2, '__idiv__': 2, '__imod__': 2, '__ilshift__': 2, |
| '__irshift__': 2, '__iand__': 2, '__ixor__': 2, '__ior__': 2, |
| '__neg__': 1, '__pos__': 1, '__abs__': 1, '__invert__': 1, |
| '__complex__': 1, '__int__': 1, '__long__': 1, '__float__': 1, |
| '__oct__': 1, '__hex__': 1, '__coerce__': 2, |
| '__new__': None, |
| '__getinitargs__': 1, '__reduce__': 1, |
| '__getstate__': 1,'__setstate__': 2, |
| '__copy__': 1, '__deepcopy__': 1, |
| '__pow__': 2, '__ipow__': 2, # 2 or 3 |
| '__call__': None, # any number > 1 |
| '__getslice__': 3, # deprecated |
| '__getattribute__': 2, |
| } |
| |
| def check_special(scope): |
| try: |
| count = special[scope.name] |
| max_args = len(scope.node.argnames) |
| min_args = max_args - len(scope.node.defaults) |
| if min_args > count or max_args < count or \ |
| scope.node.varargs or scope.node.kwargs: |
| return special[scope.name] |
| except KeyError: |
| pass |
| return None |
| |
| class SpecialCheck(Check): |
| |
| specialMethod = Warning('Report special methods with incorrect ' |
| 'number of arguments', |
| 'The %s method requires %d argument%s, ' |
| 'including self') |
| |
| notSpecial = Warning('Report methods with "__" prefix and suffix ' |
| 'which are not defined as special methods', |
| 'The method %s is not a special method, ' |
| 'but is reserved.') |
| |
| def check(self, file, unused_checker): |
| |
| for node, scope in file.class_scopes(): |
| for m in _get_methods(scope): |
| n = check_special(m) |
| if n: |
| file.warning(m.node, self.specialMethod, m.name, n, |
| n > 1 and "s" or "") |
| name = m.name |
| if name.startswith('__') and name.endswith('__') and \ |
| name != '__init__' and not special.has_key(name): |
| file.warning(m.node, self.notSpecial, name) |
| |
| class BackQuote(BaseVisitor): |
| |
| def __init__(self, selfname): |
| self.results = [] |
| self.selfname = selfname |
| |
| def visitBackquote(self, node): |
| if isinstance(node.expr, ast.Name) and node.expr.name == self.selfname: |
| self.results.append(node) |
| |
| class ReprCheck(Check): |
| |
| backquoteSelf = Warning('Report use of `self` in __repr__ methods', |
| 'Using `self` in __repr__') |
| def check(self, file, unused_checker): |
| for node, scope in file.class_scopes(): |
| for m in _get_methods(scope): |
| if m.name == '__repr__' and m.node.argnames: |
| visitor = BackQuote(m.node.argnames[0]) |
| for n in walk(m.node.code, visitor).results: |
| file.warning(n, self.backquoteSelf) |
| |
