Method initializerListOrder

lib/checkclass.cpp:2807–2884

}

void CheckClassImpl::initializerListOrder()
{
    if (!mSettings.isPremiumEnabled("initializerList")) {
        if (!mSettings.severity.isEnabled(Severity::style))
            return;

        // This check is not inconclusive.  However it only determines if the initialization
        // order is incorrect.  It does not determine if being out of order causes
        // a real error.  Out of order is not necessarily an error but you can never
        // have an error if the list is in order so this enforces defensive programming.
        if (!mSettings.certainty.isEnabled(Certainty::inconclusive))
            return;
    }

    logChecker("CheckClass::initializerListOrder"); // style,inconclusive

    for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {

        // iterate through all member functions looking for constructors
        for (auto func = scope->functionList.cbegin(); func != scope->functionList.cend(); ++func) {
            if (func->isConstructor() && func->hasBody()) {
                // check for initializer list
                const Token *tok = func->arg->link()->next();

                if (tok->str() == ":") {
                    std::vector<VarInfo> vars;
                    tok = tok->next();

                    // find all variable initializations in list
                    for (; tok && tok != func->functionScope->bodyStart; tok = tok->next()) {
                        if (Token::Match(tok, "%name% (|{")) {
                            const Token* const end = tok->linkAt(1);
                            const Variable *var = scope->getVariable(tok->str());
                            if (var)
                                vars.emplace_back(var, tok);
                            else
                                tok = end;

                            for (; tok != end; tok = tok->next()) {
                                if (Token::Match(tok->astParent(), ".|::"))
                                    continue;
                                if (const Variable* argVar = scope->getVariable(tok->str())) {
                                    if (scope != argVar->scope())
                                        continue;
                                    if (argVar->isStatic())
                                        continue;
                                    if (tok->variable() && tok->variable()->isArgument())
                                        continue;
                                    if (var->isPointer() && (argVar->isArray() || Token::simpleMatch(tok->astParent(), "&")))
                                        continue;
                                    if (var->isReference())
                                        continue;
                                    if (Token::simpleMatch(tok->astParent(), "="))
                                        continue;
                                    vars.back().initArgs.emplace_back(argVar);
                                }
                            }
                        }