Cpp.Function Class

    rule is = {
        defect Testis = 
        when Cpp.Function.is(&Function)
        raise "Function detected"
        on Function
    }

    rule name = {
        defect Testname = 
        when Cpp.Function.is(&Function)
        and Function.name(&fname)
        raise "Function detected: \"{fname}\""
        on Function
    }

    rule qualifiedName = {
        defect TestqualifiedName = 
        when Cpp.Function.is(&Function)
        and Function.qualifiedName(&qname)
        raise "Function detected: \"{qname}\""
        on Function
    }

    rule isMain = {
        defect TestisMain = 
        when Cpp.Function.is(&Function)
        and Function.isMain()
        raise "Main Function detected"
        on Function
    }

    rule isInline = {
        defect TestisInline = 
        when Cpp.Function.is(&Function)
        and Function.isInline()
        and Function.name(&fname)
        raise "Function detected: \"{fname}\" is marked as inline"
        on Function
    }

    rule isFileStatic = {
        defect TestisFileStatic = 
        when Cpp.Function.is(&Function)
        and Function.isFileStatic()
        and Function.name(&fname)
        raise "File Static Function detected: \"{fname}\""
        on Function
    }

    rule isCompilerGenerated = {
        defect TestisCompilerGenerated = 
        when Cpp.Function.is(&Function)
        and Function.isCompilerGenerated()
        and Function.name(&fname)
        raise "Compiler Generated Function detected: \"{fname}\""
        on Function
    }

    rule isDefaulted = {
        defect TestisDefaulted = 
        when Cpp.Function.is(&Function)
        and Function.isDefaulted()
        raise "Defaulted Function detected"
        on Function
    }

    rule isMemberFunction = {
        defect TestisMemberFunction = 
        when Cpp.Function.is(&Function)
        and Cpp.Type.is(&Type)
        and Type.isClass()
        and Function.isMemberFunction(&Type)
        and Function.name(&fname)    
        raise "Member Function detected: \"{fname}\""
        on Function
    }

    rule isStaticMemberFunction = {
        defect TestisStaticMemberFunction = 
        when Cpp.Function.is(&Function)
        and Cpp.Type.is(&Type)
        and Type.isClass()
        and Function.isStaticMemberFunction(&Type)
        raise "Static Member Function detected"
        on Function
    }

    rule isVirtual = {
        defect TestisVirtual = 
        when Cpp.Function.is(&Function)
        and Function.isVirtual()
        raise "Virtual Function detected"
        on Function
    }

    rule type = {
        defect Testtype = 
        when Cpp.Function.is(&Function)
        and Function.type(&ftype)
        and ftype.toString(&ftypestr)
        raise "Function detected with type: \"{ftypestr}\""
        on Function
    }

    rule returnType = {
        defect TestreturnType = 
        when Cpp.Function.is(&Function)
        and Function.returnType(&rtype)
        and rtype.toString(&rtypestr)
        and rtypestr == "int"
        raise "Function with int return type detected"
        on Function
    }

    rule declaredParameter = {
        defect TestdeclaredParameter = 
        when Cpp.Function.is(&Function)
        and Function.declaredParameter(&param, &pos)
        and param.type(&ptype)
        and ptype.toString(&ptypestr)
        and ptypestr=="int"
        and pos==0
        and param.name(&pname)
        raise "First parmater is integer \"{pname}\""
        on Function
    }

    rule numDeclaredParameters = {
        defect TestnumDeclaredParameters = 
        when Cpp.Function.is(&Function)
        and Function.numDeclaredParameters(&num)
        and num>2
        raise "Function with greater than 2 parameters detected"
        on Function
    }

    rule localVariable = {
        defect TestlocalVariable = 
        when Cpp.Function.is(&Function)
        and Function.isVirtual()
        and Function.localVariable(&var)
        and var.type(&vartype)
        and vartype.toString(&vts)
        and vts=="double"
        raise "Virtual function declares double type local variable"
        on Function
    }

    rule isDefined = {
        defect TestisDefined = 
        when Cpp.Function.is(&Function)
        and not Function.isDefined()
        raise "Undefined Function detected"
        on Function
    }

    rule isExternC = {
        defect TestisExternC = 
        when Cpp.Function.is(&Function)
        and  Function.isExternC()
        raise "Extern C Function detected"
        on Function
    }

    rule isVariadic = {
        defect TestisVariadic = 
        when Cpp.Function.is(&Function)
        and Function.isVariadic()
        raise "Variadic Function detected"
        on Function
    }

    rule isNoExcept = {
        defect TestisNoExcept = 
        when Cpp.Function.is(&Function)
        and Function.isNoExcept()
        raise "Noexcept Function detected"
        on Function
    }

    rule isNoExceptFalse = {
        defect TestisNoExceptFalse = 
        when Cpp.Function.is(&Function)
        and Function.isNoExceptFalse()
        raise "Exception throwing Function detected"
        on Function
    }

    rule overloads = {
        defect Testoverloads = 
        when Cpp.Function.is(&Function)
        and Function.overloads(&ovf)
        and Function.numDeclaredParameters(&fnum)
        and ovf.numDeclaredParameters(&ovfnum)
        and fnum != ovfnum
        raise "Function has overloads with a different number of params"
        on Function
    }

    rule hasNoPrototype = {
        defect TesthasNoPrototype = 
        when Cpp.Function.is(&Function)
        and Function.hasNoPrototype()
        and Function.name(&fname)
        raise "Function \"{fname}\" has no prototype"
        on Function
    }

    rule isImplicitlyDeclared = {
        defect TestisImplicitlyDeclared = 
        when Cpp.Function.is(&Function)
        and Function.isImplicitlyDeclared() 
        and Function.name(&fname)
        raise "Function detected: \"{fname}\" is implicitly declared"
        on Function
    }

    rule namespace = {
        defect Testnamespace = 
        when Cpp.Function.is(&Function)
        and Function.namespace(&ns)
        and ns.name(&nsname)
        raise "Function detected in namespace : \"{nsname}\""
        on Function
    }