rizsotto / constantine Goto Github PK

Currently can't reproduce the problem. It could be seen, when do checking it's own source code.

Konstantin
Constantin
Mecsek

look like that operator calls are not handling arguments properly

seems that not used variables are got blamed from headers which are included. one option could be to generate warning only on current module.

it generates false positive warnings

implement a method which returns the most const type of a declaration. this method could have a type declaration like this:

clang::QualType (*f)(clang::QualType declaration, std::set<clang::QualType> usages);

here is the related Clang documentation on types.

a member function can not be declared const if,

• mutate a member variable, which is non mutable
• call a member function, which is non const
• were declared as virtual
• override a virtual member function

http://gcc.gnu.org/wiki/Visibility

clang::DiagnosticsEngine::getCustomDiagID changed to accept string literals only.
to fix it, we might use clang::DiagnosticsEngine::Report(const StoredDiagnostic &) version, and find out the way to create StoredDiagnostic.

Here is an example where the above suggestion is raised as a false positive:

class Foo {
    friend class Bar;
};

class Bar {
    double m;
    void bar() {
        m = 0;
    }
};

false positive detected when a constructor got non const reference, because of the parent class signature requires non const signature.

methods are recommended to be static, even they were accessing 'this' pointer.

analyzing free variables might be useful.

When a reference/pointer is used/modified but the one which was refereed might be not. This case none of these shall be reported as pseudo const.

false positive case when a member method looks like this

void T::foo() {
return const_method(non_const_method());
}

currently it does blame situation like this:

struct Base {
virtual void method(int &) { }
};

struct MyType : public Base {
void method(int & k) { int const j = k; }
};

this case MyType::method shall not blame to have non const argument

currently all attributes of a POD are reported pseudo constness

a member function can not be declared static if,

• access a member variable
• call a member function
• were declared as virtual
• override a virtual member function

It would help to find when multiple declaration is omitted.

method analysis does not consider this in function calls.