bee_python 0.0.1

data/tools/pychecker/warn.py

@@ -0,0 +1,778 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2001-2002, MetaSlash Inc.  All rights reserved.
+# Portions Copyright (c) 2005, Google, Inc. All rights reserved.
+
+"""
+Print out warnings from Python source files.
+"""
+
+import os.path
+import sys
+import string
+import types
+import traceback
+import imp
+import re
+
+from pychecker import OP
+from pychecker import Stack
+from pychecker import function
+from pychecker import python
+from pychecker import pcmodules
+
+from pychecker import msgs
+from pychecker import utils
+from pychecker import CodeChecks
+from pychecker.Warning import Warning
+
+
+def cfg() :
+    return utils.cfg()
+
+def _checkSelfArg(method, warnings) :
+    """Return a Warning if there is no self parameter or
+       the first parameter to a method is not self."""
+
+    if not cfg().methodArgName:
+        return
+
+    code = method.function.func_code
+    err = None
+    if method.isStaticMethod():
+        if code.co_argcount > 0 and cfg().methodArgName == code.co_varnames[0]:
+            err = msgs.SELF_IS_ARG % 'staticmethod'
+    elif code.co_argcount < 1: 
+        err = msgs.NO_METHOD_ARGS % cfg().methodArgName
+    else:
+        if method.isClassMethod():
+            if code.co_varnames[0] not in cfg().classmethodArgNames:
+                err = msgs.SELF_NOT_FIRST_ARG % \
+                      (cfg().classmethodArgNames, 'class')
+        elif code.co_varnames[0] != cfg().methodArgName:
+            err = msgs.SELF_NOT_FIRST_ARG % (cfg().methodArgName, '')
+
+    if err is not None :
+        warnings.append(Warning(code, code, err))
+
+
+def _checkNoSelfArg(func, warnings) :
+    "Return a Warning if there is a self parameter to a function."
+
+    code = func.function.func_code
+    if code.co_argcount > 0 and cfg().methodArgName in code.co_varnames:
+        warnings.append(Warning(code, code, msgs.SELF_IS_ARG % 'function'))
+
+
+def _checkSubclass(c1, c2):
+    try:
+        return issubclass(c1.classObject, c2.classObject)
+    except (TypeError, AttributeError):
+        return 0
+
+
+_IGNORE_RETURN_TYPES = ( Stack.TYPE_FUNC_RETURN, Stack.TYPE_ATTRIBUTE,
+                         Stack.TYPE_GLOBAL, Stack.TYPE_COMPARISON,
+                         Stack.TYPE_UNKNOWN)
+
+def _checkReturnWarnings(code) :
+    is_getattr = code.func_code.co_name in ('__getattr__', '__getattribute__')
+    if is_getattr :
+        for line, retval, dummy in code.returnValues :
+            if retval.isNone() :
+                err = msgs.DONT_RETURN_NONE % code.func_code.co_name
+                code.addWarning(err, line+1)
+
+    # there must be at least 2 real return values to check for consistency
+    returnValuesLen = len(code.returnValues)
+    if returnValuesLen < 2 :
+        return
+
+    # if the last return is implicit, check if there are non None returns
+    lastReturn = code.returnValues[-1]
+
+    # Python 2.4 optimizes the dead implicit return out, so we can't
+    # distinguish implicit and explicit "return None"
+    if utils.pythonVersion() < utils.PYTHON_2_4 and \
+           not code.starts_and_ends_with_finally and \
+           cfg().checkImplicitReturns and lastReturn[1].isImplicitNone():
+        for line, retval, dummy in code.returnValues[:-1] :
+            if not retval.isNone() :
+                code.addWarning(msgs.IMPLICIT_AND_EXPLICIT_RETURNS,
+                                lastReturn[0]+1)
+                break
+
+    # __get*__ funcs can return different types, don't warn about inconsistency
+    if utils.startswith(code.func_code.co_name, '__get') and \
+       utils.endswith(code.func_code.co_name, '__') :
+        return
+
+    returnType, returnData = None, None
+    for line, value, dummy in code.returnValues :
+        if not value.isNone() :
+            valueType = value.getType(code.typeMap)
+            if returnType is None and valueType not in _IGNORE_RETURN_TYPES :
+                returnData = value
+                returnType = valueType
+                continue
+
+            # always ignore None, None can be returned w/any other type
+            # FIXME: if we stored func return values, we could do better
+            if returnType is not None and not value.isNone() and \
+               valueType not in _IGNORE_RETURN_TYPES and \
+               returnData.type not in _IGNORE_RETURN_TYPES :
+                ok = returnType in (type(value.data), valueType)
+                if ok :
+                    if returnType == types.TupleType :
+                        # FIXME: this isn't perfect, if len == 0
+                        # the length can really be 0 OR unknown
+                        # we shouldn't check the lengths for equality
+                        # ONLY IF one of the lengths is truly unknown
+                        if returnData.length > 0 and value.length > 0:
+                            ok = returnData.length == value.length
+                else :
+                    ok = _checkSubclass(returnType, valueType) or \
+                         _checkSubclass(valueType, returnType)
+                if not ok :
+                    code.addWarning(msgs.INCONSISTENT_RETURN_TYPE, line)
+
+
+def _checkComplex(code, maxValue, value, func, err) :
+    if maxValue and value > maxValue :
+        line = func.function.func_code.co_firstlineno
+        code.addWarning(err % (func.function.__name__, value), line)
+
+
+def _checkCode(code, codeSource) :
+    while code.index < code.maxCode :
+        op, oparg, operand = code.popNextOp()
+        dispatch_func = CodeChecks.DISPATCH[op]
+        if dispatch_func is not None :
+            dispatch_func(oparg, operand, codeSource, code)
+
+def _name_unused(var) :
+    if var in cfg().unusedNames :
+        return 0
+    for name in cfg().unusedNames :
+        if name != '_' and utils.startswith(var, name) :
+            return 0
+    return 1
+
+def _checkUnusedParam(var, line, func, code) :
+    if line is not None and line == 0 and _name_unused(var) :
+        if ((cfg().ignoreSelfUnused or var != cfg().methodArgName) and
+            (cfg().varArgumentsUsed or func.varArgName() != var)) :
+            code.addWarning(msgs.UNUSED_PARAMETER % var, code.func_code)
+
+def _handleNestedCode(func_code, code, codeSource):
+    nested = not (codeSource.main or codeSource.in_class)
+    if func_code.co_name == utils.LAMBDA or nested:
+        utils.debug(' handling nested code')
+        varnames = None
+        if nested and func_code.co_name != utils.LAMBDA:
+            varnames = func_code.co_varnames + \
+                     codeSource.calling_code[-1].function.func_code.co_varnames
+        # save the original return value and restore after checking
+        returnValues = code.returnValues
+        code.init(function.create_fake(func_code.co_name, func_code, {},
+                                       varnames))
+        _checkCode(code, codeSource)
+        code.returnValues = returnValues
+
+def _findUnreachableCode(code) :
+    # code after RETURN or RAISE is unreachable unless there's a branch to it
+    unreachable = {}
+    terminals = code.returnValues[:-1] + code.raiseValues
+    terminals.sort(lambda a, b: cmp(a[2], b[2]))
+    for line, dummy, i in terminals :
+        if not code.branches.has_key(i) :
+            unreachable[i] = line
+
+    # find the index of the last return
+    lastLine = lastItem = lastIndex = None
+    if code.returnValues:
+        lastLine, lastItem, lastIndex = code.returnValues[-1]
+    if len(code.returnValues) >= 2 :
+        lastIndex = code.returnValues[-2][2]
+    if code.raiseValues :
+        lastIndex = max(lastIndex, code.raiseValues[-1][2])
+
+    # remove last return if it's unreachable AND implicit
+    if unreachable.get(lastIndex) == lastLine and lastItem and \
+           lastItem.isImplicitNone():
+        del code.returnValues[-1]
+        del unreachable[lastIndex]
+
+    if cfg().unreachableCode :
+        for index in unreachable.keys() :
+            try :
+                if not OP.JUMP_FORWARD(ord(code.bytes[index])) :
+                    code.addWarning(msgs.CODE_UNREACHABLE, unreachable[index])
+            except IndexError :
+                pass
+
+
+def _checkFunction(module, func, c = None, main = 0, in_class = 0) :
+    "Return a list of Warnings found in a function/method."
+
+    # always push a new config object, so we can pop at end of function
+    utils.pushConfig()
+
+    code = CodeChecks.Code()
+    code.init(func)
+    if main:
+        for key in func.function.func_globals.keys():
+            code.unusedLocals[key] = -1
+    codeSource = CodeChecks.CodeSource(module, func, c, main, in_class, code)
+    try :
+        _checkCode(code, codeSource)
+        if not in_class :
+            _findUnreachableCode(code)
+
+        # handle lambdas and nested functions
+        codeSource.calling_code.append(func)
+        for func_code in code.codeObjects.values() :
+            _handleNestedCode(func_code, code, codeSource)
+        del codeSource.calling_code[-1]
+
+    except (SystemExit, KeyboardInterrupt) :
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        raise exc_type, exc_value
+    except :
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        exc_list = traceback.format_exception(exc_type, exc_value, exc_tb)
+        for index in range(0, len(exc_list)) :
+            exc_list[index] = string.replace(exc_list[index], "\n", "\n\t")
+        code.addWarning(msgs.CHECKER_BROKEN % string.join(exc_list, ""))
+
+    if cfg().checkReturnValues :
+        _checkReturnWarnings(code)
+
+    if cfg().localVariablesUsed :
+        for var, line in code.unusedLocals.items() :
+            if line is not None and line > 0 and _name_unused(var) :
+                code.addWarning(msgs.UNUSED_LOCAL % var, line)
+
+    if cfg().argumentsUsed :
+        op = code.getFirstOp()
+        if not (OP.RAISE_VARARGS(op) or OP.RETURN_VALUE(op)) :
+            for var, line in code.unusedLocals.items() :
+                _checkUnusedParam(var, line, func, code)
+
+    # Check code complexity:
+    #   loops should be counted as one branch, but there are typically 3
+    #   branches in byte code to setup a loop, so subtract off 2/3's of them
+    #    / 2 to approximate real branches
+    branches = (len(code.branches.keys()) - (2 * code.loops)) / 2
+    lines = (code.getLineNum() - code.func_code.co_firstlineno)
+    returns = len(code.returnValues)
+    if not main and not in_class :
+        args = code.func_code.co_argcount
+        locals = len(code.func_code.co_varnames) - args
+        _checkComplex(code, cfg().maxArgs, args, func, msgs.TOO_MANY_ARGS)
+        _checkComplex(code, cfg().maxLocals, locals, func, msgs.TOO_MANY_LOCALS)
+        _checkComplex(code, cfg().maxLines, lines, func, msgs.FUNC_TOO_LONG)
+    _checkComplex(code, cfg().maxReturns, returns, func, msgs.TOO_MANY_RETURNS)
+    _checkComplex(code, cfg().maxBranches, branches, func, msgs.TOO_MANY_BRANCHES)
+
+    if not (main or in_class) :
+        utils.popConfig()
+    func.returnValues = code.returnValues
+    return (code.warnings, code.globalRefs, code.functionsCalled,
+            code.codeObjects.values(), code.returnValues)
+
+
+def _getUnused(module, globalRefs, dict, msg, filterPrefix = None) :
+    "Return a list of warnings for unused globals"
+
+    warnings = []
+    for ref in dict.keys() :
+        check = not filterPrefix or utils.startswith(ref, filterPrefix)
+        if check and globalRefs.get(ref) == None :
+            lineInfo = module.moduleLineNums.get(ref)
+            if lineInfo:
+                warnings.append(Warning(lineInfo[0], lineInfo[1], msg % ref))
+    return warnings
+
+
+def _get_func_info(method) :
+    try:
+        fc = getattr(method.im_func, 'func_code', None)
+        if fc is not None :
+            return fc.co_filename, fc.co_firstlineno
+    except AttributeError:
+        # if the object derives from any object in 2.2,
+        # the builtin methods are wrapper_descriptors and
+        # have no im_func attr
+        pass
+    return None, None
+
+_DOT_INIT = '.' + utils.INIT
+
+def _baseInitCalled(classInitInfo, base, functionsCalled) :
+    baseInit = getattr(base, utils.INIT, None)
+    if baseInit is None or _get_func_info(baseInit) == classInitInfo :
+        return 1
+
+    initName = utils.safestr(base) + _DOT_INIT
+    if functionsCalled.has_key(initName) :
+        return 1
+
+    # ok, do this the hard way, there may be aliases, so check here
+    names = string.split(initName, '.')
+
+    # first look in our list of PyCheckerModules
+    moduleName = names[0]
+    moduleDir = os.path.dirname(classInitInfo[0])
+    pcmodule = pcmodules.getPCModule(moduleName, moduleDir)
+    if pcmodule:
+        obj = pcmodule.module
+    else:
+        # fall back to looking in sys.modules
+        try:
+            # i think this can raise an exception if the module is a library
+            # (.so)
+            obj = sys.modules[names[0]]
+        except KeyError:
+            return 1
+    for i in range(1, len(names)) :
+        obj = getattr(obj, names[i], None)
+        if obj is None:
+            return 0
+        if functionsCalled.has_key(string.join(names[i:], '.')) :
+            return 1
+
+    return 0
+
+def _checkBaseClassInit(moduleFilename, c, func_code, funcInfo) :
+    """Return a list of warnings that occur
+       for each base class whose __init__() is not called"""
+
+    warnings = []
+    functionsCalled, _, returnValues = funcInfo
+    for line, stackItem, dummy in returnValues :
+        if stackItem.data != None :
+            if not stackItem.isNone() or cfg().returnNoneFromInit :
+                warn = Warning(func_code, line, msgs.RETURN_FROM_INIT)
+                warnings.append(warn)
+
+    classInit = getattr(c.classObject, utils.INIT, None)
+    if cfg().baseClassInitted and classInit is not None :
+        classInitInfo = _get_func_info(classInit)
+        for base in getattr(c.classObject, '__bases__', None) or ():
+            if not _baseInitCalled(classInitInfo, base, functionsCalled):
+                warn = Warning(moduleFilename, func_code,
+                               msgs.BASE_CLASS_NOT_INIT % utils.safestr(base))
+                warnings.append(warn)
+    return warnings
+
+
+def _checkOverridenMethods(func, baseClasses, warnings) :
+    for baseClass in baseClasses :
+        if func.func_name != utils.INIT and \
+           not function.same_signature(func, baseClass) :
+            err = msgs.METHOD_SIGNATURE_MISMATCH % (func.func_name, utils.safestr(baseClass))
+            warnings.append(Warning(func.func_code, func.func_code, err))
+            break
+
+
+def _updateFunctionWarnings(module, func, c, warnings, globalRefs,
+                            main = 0, in_class = 0) :
+    "Update function warnings and global references"
+
+    newWarnings, newGlobalRefs, funcs, codeObjects, returnValues = \
+                 _checkFunction(module, func, c, main, in_class)
+    warnings.extend(newWarnings)
+    globalRefs.update(newGlobalRefs)
+
+    return funcs, codeObjects, returnValues
+
+
+def getBlackList(moduleList) :
+    blacklist = []
+    for badBoy in moduleList :
+        if badBoy[-3:] == ".py":
+            badBoy = badBoy[0:-3]
+        try :
+            file, path, flags = imp.find_module(badBoy)
+            if file :
+                file.close()
+            # apparently, imp.find_module can return None, path, (triple)
+            # This happened to me with twisted 2.2.0 in a separate path
+            if path:
+                blacklist.append(normalize_path(path))
+        except ImportError :
+            pass
+    return blacklist
+
+def getStandardLibraries() :
+    """
+    Return a list of standard libraries.
+
+    @rtype: list of str or None
+    """
+    if cfg().ignoreStandardLibrary :
+        try :
+            from distutils import sysconfig
+
+            std_libs = [
+                sysconfig.get_python_lib(plat_specific=0),
+                sysconfig.get_python_lib(plat_specific=1)
+            ]
+            ret = []
+            for std_lib in std_libs:
+                path = os.path.split(std_lib)
+                if path[1] == 'site-packages' :
+                    ret.append(path[0])
+            return ret
+        except ImportError :
+            return None
+
+def normalize_path(path):
+    return os.path.normpath(os.path.normcase(path))
+
+def removeWarnings(warnings, blacklist, std_lib, cfg):
+    """
+    @param blacklist: list of absolute paths not to warn for
+    @type  blacklist: str
+    @param std_lib:   list of standard library directories
+    @type  std_lib:   list of str or None
+    """
+    if std_lib is not None:
+        std_lib = [normalize_path(p) for p in std_lib]
+    for index in range(len(warnings)-1, -1, -1) :
+        filename = normalize_path(warnings[index].file)
+        # the blacklist contains paths to packages and modules we do not
+        # want warnings for
+        # when we find a match, make sure we continue the warnings for loop
+        found = False
+        for path in blacklist:
+            if not found and filename.startswith(path):
+                found = True
+                del warnings[index]
+        if found:
+            continue
+        if std_lib:
+            found = False
+            for path in std_lib:
+                if not found and utils.startswith(filename, path) :
+                    found = True
+                    del warnings[index]
+            if found:
+                continue
+        elif cfg.only:
+            # ignore files not specified on the cmd line if requested
+            if os.path.abspath(filename) not in cfg.files:
+                del warnings[index]
+                continue
+
+        # filter by warning/error level if requested
+        if cfg.level and warnings[index].level < cfg.level:
+            del warnings[index]
+
+    if cfg.limit:
+        # sort by severity first, then normal sort (by file/line)
+        warnings.sort(lambda a, b: cmp(a.level, b.level) or cmp(a, b))
+
+        # strip duplicates
+        lastWarning = None
+        for index in range(len(warnings)-1, -1, -1):
+            warning = warnings[index]
+
+            # remove duplicate warnings
+            if lastWarning is not None and cmp(lastWarning, warning) == 0:
+                del warnings[index]
+            else:
+                lastWarning = warning
+
+        num_ignored = len(warnings) - cfg.limit
+        if num_ignored > 0:
+            del warnings[:-cfg.limit]
+            msg = msgs.TOO_MANY_WARNINGS % num_ignored
+            warnings.append(Warning('', 0, msg))
+
+    return warnings
+
+
+class _SuppressionError(Exception) :
+    pass
+
+def _updateSuppressions(suppress, warnings) :
+    if not utils.updateCheckerArgs(suppress, 'suppressions', 0, warnings) :
+        utils.popConfig()
+        raise _SuppressionError
+
+_CLASS_NAME_RE = re.compile("<class '([A-Za-z0-9.]+)'>(\\..+)?")
+
+def getSuppression(name, suppressions, warnings) :
+    try :
+        utils.pushConfig()
+
+        # cheesy hack to deal with new-style classes.  i don't see a
+        # better way to get the name, '<' is an invalid identifier, so
+        # we can reliably check it and extract name from:
+        # <class 'class-name'>[.identifier[.identifier]...]
+        matches = _CLASS_NAME_RE.match(name)
+        if matches:
+            # pull out the names and make a complete identifier (ignore None)
+            name = string.join(filter(None, matches.groups()), '')
+
+        suppress = suppressions[0].get(name, None)
+        if suppress is not None :
+            _updateSuppressions(suppress, warnings)
+
+        regexList = suppressions[1].keys()
+        regexList.sort()
+        for regex in regexList :
+            match = regex.match(name)
+            if match and match.group() == name :
+                suppress = 1
+                _updateSuppressions(suppressions[1][regex], warnings)
+
+        if not suppress :
+            utils.popConfig()
+
+        return suppress
+    except _SuppressionError :
+        return None
+
+def _findFunctionWarnings(module, globalRefs, warnings, suppressions) :
+    for func in module.functions.values() :
+        func_code = func.function.func_code
+        utils.debug("function:", func_code)
+
+        name = '%s.%s' % (module.moduleName, func.function.__name__)
+        suppress = getSuppression(name, suppressions, warnings)
+        if cfg().noDocFunc and func.function.__doc__ == None :
+            err = msgs.NO_FUNC_DOC % func.function.__name__
+            warnings.append(Warning(module.filename(), func_code, err))
+
+        _checkNoSelfArg(func, warnings)
+        _updateFunctionWarnings(module, func, None, warnings, globalRefs)
+        if suppress is not None :
+            utils.popConfig()
+
+def _getModuleFromFilename(module, filename):
+    if module.filename() != filename:
+        for m in module.modules.values():
+            if m.filename() == filename:
+                return m
+    return module
+
+# Create object for non-2.2 interpreters, any class object will do
+try:
+    if object: pass
+except NameError:
+    object = _SuppressionError
+
+# Create property for pre-2.2 interpreters
+try :
+    if property: pass
+except NameError:
+    property = None
+
+def _findClassWarnings(module, c, class_code,
+                       globalRefs, warnings, suppressions) :
+    try:
+        className = utils.safestr(c.classObject)
+    except TypeError:
+        # goofy __getattr__
+        return
+    classSuppress = getSuppression(className, suppressions, warnings)
+    baseClasses = c.allBaseClasses()
+    for base in baseClasses :
+        baseModule = utils.safestr(base)
+        if '.' in baseModule :
+            # make sure we handle import x.y.z
+            packages = string.split(baseModule, '.')
+            baseModuleDir = string.join(packages[:-1], '.')
+            globalRefs[baseModuleDir] = baseModule
+
+    # handle class variables
+    if class_code is not None :
+        func = function.create_fake(c.name, class_code)
+        _updateFunctionWarnings(module, func, c, warnings, globalRefs, 0, 1)
+
+    filename = module.filename()
+    func_code = None
+    for method in c.methods.values() :
+        if method == None :
+            continue
+        func_code = method.function.func_code
+        utils.debug("method:", func_code)
+
+        try:
+            name = utils.safestr(c.classObject) + '.' + method.function.func_name
+        except AttributeError:
+            # func_name may not exist
+            continue
+        methodSuppress = getSuppression(name, suppressions, warnings)
+
+        if cfg().checkSpecialMethods:
+            funcname = method.function.func_name
+            if funcname[:2] == '__' == funcname[-2:] and \
+               funcname != '__init__':
+                err = None
+                argCount = python.SPECIAL_METHODS.get(funcname, -1)
+                if argCount != -1:
+                    # if the args are None, it can be any # of args
+                    if argCount is not None:
+                        minArgs = maxArgs = argCount
+                        err = CodeChecks.getFunctionArgErr(funcname,
+                                     func_code.co_argcount, minArgs, maxArgs)
+                else:
+                    err = msgs.NOT_SPECIAL_METHOD % funcname
+
+                if err is not None:
+                    warnings.append(Warning(filename, func_code, err))
+                
+        if cfg().checkOverridenMethods :
+            _checkOverridenMethods(method.function, baseClasses, warnings)
+
+        if cfg().noDocFunc and method.function.__doc__ == None :
+            err = msgs.NO_FUNC_DOC % method.function.__name__
+            warnings.append(Warning(filename, func_code, err))
+
+        _checkSelfArg(method, warnings)
+        tmpModule = _getModuleFromFilename(module, func_code.co_filename)
+        funcInfo = _updateFunctionWarnings(tmpModule, method, c, warnings, globalRefs)
+        if func_code.co_name == utils.INIT :
+            if utils.INIT in dir(c.classObject) :
+                warns = _checkBaseClassInit(filename, c, func_code, funcInfo)
+                warnings.extend(warns)
+            elif cfg().initDefinedInSubclass :
+                err = msgs.NO_INIT_IN_SUBCLASS % c.name
+                warnings.append(Warning(filename, c.getFirstLine(), err))
+        if methodSuppress is not None :
+            utils.popConfig()
+
+    if c.memberRefs and cfg().membersUsed :
+        memberList = c.memberRefs.keys()
+        memberList.sort()
+        err = msgs.UNUSED_MEMBERS % (string.join(memberList, ', '), c.name)
+        warnings.append(Warning(filename, c.getFirstLine(), err))
+
+    try:
+        newStyleClass = issubclass(c.classObject, object)
+    except TypeError:
+        # FIXME: perhaps this should warn b/c it may be a class???
+        newStyleClass = 0
+
+    slots = c.statics.get('__slots__')
+    if slots is not None and cfg().slots:
+        lineNum = c.lineNums['__slots__']
+        if not newStyleClass:
+            err = msgs.USING_SLOTS_IN_CLASSIC_CLASS % c.name
+            warnings.append(Warning(filename, lineNum, err))
+        elif cfg().emptySlots:
+            try:
+                if len(slots.data) == 0:
+                    err = msgs.EMPTY_SLOTS % c.name
+                    warnings.append(Warning(filename, lineNum, err))
+            except AttributeError:
+                # happens when slots is an instance of a class w/o __len__
+                pass
+
+    if not newStyleClass and property is not None and cfg().classicProperties:
+        for static in c.statics.keys():
+            if type(getattr(c.classObject, static, None)) == property:
+                err = msgs.USING_PROPERTIES_IN_CLASSIC_CLASS % (static, c.name)
+                warnings.append(Warning(filename, c.lineNums[static], err))
+
+    coerceMethod = c.methods.get('__coerce__')
+    if newStyleClass and coerceMethod:
+        lineNum = coerceMethod.function.func_code.co_firstlineno
+        err = msgs.USING_COERCE_IN_NEW_CLASS % c.name
+        warnings.append(Warning(filename, lineNum, err))
+
+    for newClassMethodName in python.NEW_STYLE_CLASS_METHODS:
+        newClassMethod = c.methods.get(newClassMethodName)
+        if not newStyleClass and newClassMethod:
+            lineNum = newClassMethod.function.func_code.co_firstlineno
+            err = msgs.USING_NEW_STYLE_METHOD_IN_OLD_CLASS % (newClassMethodName, c.name)
+            warnings.append(Warning(filename, lineNum, err))
+
+    if cfg().noDocClass and c.classObject.__doc__ == None :
+        method = c.methods.get(utils.INIT, None)
+        if method != None :
+            func_code = method.function.func_code
+        # FIXME: check to make sure this is in our file,
+        #        not a base class file???
+        err = msgs.NO_CLASS_DOC % c.classObject.__name__
+        warnings.append(Warning(filename, func_code, err))
+
+    # we have to do this here, b/c checkFunction doesn't popConfig for classes
+    # this allows us to have __pychecker__ apply to all methods
+    # when defined at class scope
+    if class_code is not None :
+        utils.popConfig()
+
+    if classSuppress is not None :
+        utils.popConfig()
+
+
+def find(moduleList, initialCfg, suppressions = None) :
+    "Return a list of warnings found in the module list"
+
+    if suppressions is None :
+        suppressions = {}, {}
+
+    utils.initConfig(initialCfg)
+
+    warnings = []
+    for module in moduleList :
+        if module.moduleName in cfg().blacklist :
+            continue
+
+        modSuppress = getSuppression(module.moduleName, suppressions, warnings)
+        globalRefs, classCodes = {}, {}
+
+        # main_code can be null if there was a syntax error
+        if module.main_code != None :
+            funcInfo = _updateFunctionWarnings(module, module.main_code,
+                                               None, warnings, globalRefs, 1)
+            for code in funcInfo[1] :
+                classCodes[code.co_name] = code
+
+        _findFunctionWarnings(module, globalRefs, warnings, suppressions)
+
+        for c in module.classes.values() :
+            _findClassWarnings(module, c, classCodes.get(c.name),
+                               globalRefs, warnings, suppressions)
+
+        if cfg().noDocModule and \
+           module.module != None and module.module.__doc__ == None :
+            warnings.append(Warning(module.filename(), 1, msgs.NO_MODULE_DOC))
+
+        if cfg().allVariablesUsed or cfg().privateVariableUsed :
+            prefix = None
+            if not cfg().allVariablesUsed :
+                prefix = "_"
+            for ignoreVar in cfg().variablesToIgnore + cfg().unusedNames :
+                globalRefs[ignoreVar] = ignoreVar
+            warnings.extend(_getUnused(module, globalRefs, module.variables,
+                                       msgs.VAR_NOT_USED, prefix))
+        if cfg().importUsed :
+            if module.moduleName != utils.INIT or cfg().packageImportUsed :
+                # always ignore readline module, if [raw_]input() is used
+                if globalRefs.has_key('input') or \
+                   globalRefs.has_key('raw_input'):
+                    globalRefs['readline'] = 0
+                warnings.extend(_getUnused(module, globalRefs, module.modules,
+                                           msgs.IMPORT_NOT_USED))
+
+        if module.main_code != None :
+            utils.popConfig()
+        if modSuppress is not None :
+            utils.popConfig()
+
+    std_lib = None
+    if cfg().ignoreStandardLibrary :
+        std_lib = getStandardLibraries()
+    return removeWarnings(warnings, getBlackList(cfg().blacklist), std_lib,
+                          cfg())
+
+if 0:
+    # if you want to test w/psyco, include this
+    import psyco
+    psyco.bind(_checkCode)